Bradesco MCP

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

No contradiction with annotations. Annotations indicate idempotentHint=true and destructiveHint=false, which the description supports. It adds behavioral specifics: the permanent method requires config changes, session method via tool call, and the token parameter usage.

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

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

The description is detailed but front-loads key info and is structured into scenarios. Slightly verbose but acceptable for 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?

Given the simple input schema (1 optional param, no output schema), the description covers both use cases and return behavior adequately. It could explicitly state the response format but is sufficient.

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

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

Schema coverage is 0% with a single optional token parameter. The description explains its meaning: 'call with { token: "<jwt>" } after the user pastes, or with no args to get the link', which fully clarifies 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's purpose: authenticating users for IDE agents. It specifies verbs like 'log in', 'copy', 'paste', and explains both permanent and session-only methods, distinguishing it from siblings like 'connect'.

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 provides when to use each method: 'Best: add it to this server's config as a header... for a permanent, non-expiring connection' vs 'paste it here for a session-only login'. It also instructs to call with or without token to get a link.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds useful behavioral details about the return values in different states, without contradicting annotations.

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

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

Two concise sentences, front-loaded with the core purpose, no wasted words.

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

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

Given no output schema, the description adequately explains the return values and cases. No missing context for a simple status-check tool.

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

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

No parameters exist, so schema coverage is 100%. The description correctly does not need to add parameter info. Base score 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 it returns connection status and URLs, and explains the different cases (all connected vs missing credentials). It distinguishes itself 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 indicates when to use the tool based on connection state, but does not explicitly contrast with alternatives like 'authenticate'. However, the context is clear.

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

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

The description adds significant behavioral details beyond annotations: invoke works even without installation, returns connect/checkout links for auth/payment, writes need owner/admin. Annotations only provide readOnlyHint false, openWorldHint true, etc., so description enriches with practical constraints.

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 (approx. 400 words) but well-structured, starting with the overall purpose then breaking down into action details. Every sentence adds value, though some repetition exists. Could be slightly trimmed, but the density of information is high.

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 covers the main use cases and flows. It explains the distinction between invoke and install, admin requirements, and error handling (connect/checkout). However, it doesn't describe return values for specific actions like search or list_tools, which would be helpful.

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 clarify parameters. It does explain the 'action' enum and mentions 'mcp_id', 'tool_id', 'arguments' in context, but many parameters (limit, query, message, future, etc.) are not described. The user can infer some from the flow, but explicit mapping is missing.

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 this is the official marketplace for MCPs/tools, and details its core functionality: search, describe, install, uninstall, invoke, etc. It explicitly distinguishes itself from external registries and sibling tools by saying 'use THIS tool FIRST'. The verb 'find', 'run', 'install' 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?

Provides explicit guidance on when to use this tool (before any external registry) and when not (prefer invoke over install for occasional use, require owner/admin for writes). It even outlines the core flow: search → describe → invoke. Also mentions alternatives like install for permanent addition.

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 destructiveHint=true. The description adds context: 'deletes the connection data' and 'data will no longer be available', and mentions a return URL for re-connection. No contradiction with annotations.

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

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

Two sentences with no wasted words. First sentence states the action, second adds consequence and return value. Front-loaded 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 one-parameter tool with no output schema, the description covers consequences and return value. However, it lacks clarification on the 'item' parameter and misses potential prerequisites (e.g., existing connection). Could be more 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 one required parameter 'item' with no description (0% coverage). The description only says 'specific bank' without explaining what value to provide for 'item' (e.g., connection ID, bank code). This is insufficient for an agent to determine the parameter's 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 revokes Open Finance consent for a specific bank and deletes connection data. It uses a specific verb ('revokes', 'deletes') and resource ('bank connection'). This distinguishes it from siblings which list, sync, or get data.

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 disconnecting a bank, but does not explicitly state when to use vs alternatives or when not to use. It clearly states the consequence (data no longer available) and return (re-connect URL), which helps decision-making.

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 polling behavior up to 60s, return structure with status fields like 'needs_action' and 'timed_out', and clarifies it does not require disconnect/reconnect. No contradiction with annotations (readOnlyHint=false, destructiveHint=false).

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

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

Single dense paragraph, front-loaded with action. Some redundancy (e.g., 'NOW' capitalization) but overall efficient. Could benefit from bullet points for readability.

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 details return object fully. Sibling tools are many, yet this description clarifies its unique role. Complete for a sync operation with polling mechanics.

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 parameters: 'items' as array of selectors (item_id, connector_id, connector_name) and 'wait' as boolean toggle. Adds meaning beyond schema types.

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 describes forcing a bank re-sync with waiting. Uses specific verb 'force sync' and resource 'bank connections'. Distinguishes from siblings like openfinance_get_item_status and openfinance_list_transactions via usage guidance.

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?

States when to use ('balance or transaction list looks stale') and provides options (omit items for all, wait: false for fire-and-forget). Mentions fallback to openfinance_get_item_status for timed_out, but lacks explicit when-not to use this tool versus checking status first.

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 detailed behavioral traits beyond annotations, including handling of CREDIT accounts with BALANCE_FETCH_ERROR, degradation to last-synced balance when upstream is unavailable, and structured warnings instead of errors. No contradictions with annotations.

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

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

The description is informative and front-loaded with purpose and endpoint. It contains four sentences, each adding value, though it could be slightly more concise for a balance 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 output schema, the description fully explains the response shape `{ results: [...], errors: [{ id, status, message }] }` and covers all error and degradation scenarios, providing complete contextual information 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 description coverage, the description adds significant meaning by specifying the `account_ids` array constraint (1-50 items) and explaining per-account behavior and error handling, compensating for the lack of schema descriptions.

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

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

The description clearly states the tool returns real-time balance per account ID, specifies the endpoint GET /accounts/:id/balance, and distinguishes from other tools in the sibling list by focusing on account balance.

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

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

The description provides guidance on using the `account_ids` parameter as an array of 1-50 items and explains error behavior and degradation scenarios. It does not explicitly mention when not to use this tool or name alternatives, but the context is clear enough.

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

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

Beyond the readOnlyHint annotation, the description reveals the provider_incident block and unreliability of credit limits/balances, which is critical for safe usage.

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

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

Two sentences; first defines purpose and input, second adds essential warning. No redundant 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?

Covers input, output shape, and a key edge case (provider incident). Without an output schema, it explains the batch shape and reliability issue, but could detail account object structure more.

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 adds value by specifying array size (1-50) and batch shape. However, it does not explain what the array items represent beyond being IDs.

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 identifies the batch shape. It distinguishes from siblings like openfinance_list_accounts by emphasizing per-ID detail.

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

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

Provides input constraints (array size 1-50) and warns about provider incidents, but does not explicitly contrast with alternatives or state when not to use.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint. Description adds critical behavioral details: batch response shape ({results, errors}), Pluggy's missing paid/status field, payment[] meaning (previous bill payment), and sparse creditCardMetadata.billId hint. 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?

Every sentence adds value; front-loaded with main purpose, then usage guidance, then caveats. No redundancy or filler. Well-structured though lengthy, justified by 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?

With no output schema, description fully explains return format, prerequisites, related tools, and behavioral nuances. For a tool with one required parameter, it is complete and leaves no ambiguity.

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% parameter description coverage but description fully compensates: explains bill_ids is an array, tells how to obtain IDs (from list_credit_card_bills), and describes response shape. The description adds all necessary 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 explicitly states it returns bill-level detail for credit card bills by ID, lists exact response fields (financeCharges, payments[]), and clearly distinguishes from itemized transaction retrieval (openfinance_list_transactions). It also notes what it does NOT do, 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?

Provides clear guidance: use openfinance_list_credit_card_bills first to discover IDs, for itemized transactions use openfinance_list_transactions with date range matching billing cycle, warns against reconstructing bill totals from transactions, explains payment nuance in Brazilian Open Finance, and notes absent status field.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description adds valuable behavioral details: it specifies the returned status values, the dual response structure (`{ count, items }` vs single bank object), and the effect of omitting the parameter. This is sufficient given the annotations already communicate 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 two sentences, front-loaded with the core purpose and result. Every sentence adds distinct value without redundancy. Highly efficient and 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 the tool has a single optional parameter and no output schema, the description covers the main functionality: it lists possible statuses, describes the two response formats, and explains parameter usage. Minor gaps exist (e.g., error states when `item` is invalid), but overall it is sufficiently complete for a read-only status 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% coverage for the `item` parameter. The description compensates partially by explaining its effect (omit for all, pass for single), but lacks details like the expected format, constraints, or what constitutes a valid `item` 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 that the tool returns the current status of a bank connection, listing possible status values. It differentiates between returning status for all banks or a single bank via the `item` parameter, but does not explicitly compare to 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?

The description provides clear guidance on when to omit or pass the `item` parameter, but lacks explicit instruction on when to use this tool versus similar siblings (e.g., `openfinance_list_connections`). Use cases are implied but not contrasted.

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: the batch shape `{ results, errors }`, the array size limit (1-50), and the specific fields returned. This provides useful context without contradiction.

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

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

The description is two sentences, with the first sentence listing many fields. It is moderately concise and front-loaded with the purpose. It could be slightly more structured, but it effectively conveys all necessary information without unnecessary words.

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

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

For a read-only retrieval tool with one parameter and no output schema, the description covers the return fields, batch shape, usage sequence, and parameter limits. It is sufficient for effective use, though it could briefly mention error handling for invalid loan_ids.

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

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

Schema coverage is 0%, so the description must carry the burden. The description adds meaning by stating 'Pass `loan_ids` as an array (1-50).' This clarifies the parameter's type, cardinality, and constraint (1-50 items), which the schema alone does not specify.

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

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

The description explicitly states 'Returns full loan contract detail by id', lists many specific fields returned, and distinguishes itself by saying 'Use after openfinance_list_loans to deep-dive on a specific contract.' This clearly differentiates it from sibling tools.

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

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

The description provides explicit usage guidance: 'Use after openfinance_list_loans to deep-dive on a specific contract.' It also gives parameter constraints: 'Pass `loan_ids` as an array (1-50).' This clearly indicates when and how to use the 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?

Discloses provider_incident block affecting reliability, and notes credit balance meaning is connector-dependent. 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?

Lengthy but well-structured; every sentence adds value. Could be slightly more concise, but justified by 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?

Compensates for missing output schema by detailing returned fields and special blocks (provider_incident), ensuring agent understands output.

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, description thoroughly explains 'item' (optional filter) and 'type' (enum with BANK/CREDIT) with usage context.

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 accounts for a bank connection, lists types (BANK, CREDIT) and fields, and 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 explains when to omit or pass 'item', warns about credit balance interpretation, and directs to alternative tool for standardized bill amounts.

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 provide safety profile (readOnly, idempotent, non-destructive). Description adds caching behavior and response structure (fields like id, description, parentId), 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 covering purpose, contents, and key details (caching, field descriptions, link to sibling). No fluff, front-loaded.

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?

Description explains the response fields and caching, and connects to sibling tool. Could optionally mention if the cache needs a prior sync, but overall complete for a simple list tool.

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

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

No parameters exist, schema coverage is 100%. Description adds nothing about parameters, which is fine as baseline for zero-parameter tools 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?

Description clearly states 'Returns Pluggy's transaction category taxonomy' with specific resource and action. Explains the returned fields and links to a sibling tool that uses the categoryId, distinguishing it from other list 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?

Description provides clear context: cached for session, single aggregated response, and mentions the categoryId is used by openfinance_update_transaction_category. However, no explicit guidance on when not to use this tool vs siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds value by detailing the returned fields and the add_connection_url, but does not disclose additional behavioral traits like rate limits or auth requirements.

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

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

A single sentence that is front-loaded with the action and resource, containing only essential information with no wasted words.

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

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

For a simple list tool with no parameters and no output schema, the description adequately specifies the return fields. No pagination or limits are mentioned, but given simplicity, completeness is sufficient.

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

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

The input schema has zero parameters with 100% coverage, so the description has no need to explain parameters. The baseline of 4 is appropriate as there is no missing information.

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 'Returns' and the resource 'saved bank connections', specifying the exact fields returned (connector_id, item_id, bank name, add_connection_url). This distinguishes it from sibling tools like openfinance_list_accounts or openfinance_list_transactions.

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

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

The description implies usage when needing to view saved bank connections, but lacks explicit guidance on when not to use it or how it compares to other list tools like openfinance_list_accounts. No mention of prerequisites or alternatives.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description extensively discloses derived fields (payment_status logic, future_bills confidence), connector limitations (open_bill not available, bill_grouping_reliability warning), and payment cycle semantics. 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 very long and dense, containing essential but complex information. It is well-structured with bolded warnings and sections, but the length may overwhelm an AI agent. Some redundancy (e.g., repeating 'open_bill.available is false' details). Could be more concise while retaining completeness.

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

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

Without an output schema, the description fully explains the response structure: account echo block, results array fields, open_bill object, future_bills, payment_status_legend, and warnings. Covers error handling (returns warning instead of failing). Every critical behavioral aspect is addressed.

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 explain parameters. It thoroughly explains account_id, account_ids (bulk), and include_open_bill with detailed semantics. However, page and page_size are not explicitly described, though they are standard pagination parameters. The description compensates well for the lack of schema descriptions.

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

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

The description clearly specifies that the tool returns CLOSED credit card bills for a CREDIT-type account, listing specific fields (dueDate, totalAmount, etc.). It distinguishes from sibling tools like openfinance_get_credit_card_bill (singular bill) and openfinance_list_transactions (individual transactions).

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

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

Provides explicit when-to-use and when-not-to-use guidance: use for closed bills, opt-in for open bill with include_open_bill. Warns about connector asymmetry, not to assume payment status from payments array, and directs to openfinance_list_transactions for itemized charges. Also warns against reconstructing totals by billId.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable context: the tool returns a structured error response with a warning instead of throwing exceptions, and lists the available fields in each row. 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 covering purpose, types, and response fields. While informative, it lacks structure (e.g., bullet points) and contains some redundancy. It is moderately concise but could be better organized.

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

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

The description thoroughly covers the response structure and error handling, but lacks any documentation for the input parameters. With 4 parameters, no required fields, and no output schema, the description insufficiently equips the agent to use the tool correctly.

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

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

The input schema has 4 parameters (item, page, type, page_size) with 0% schema description coverage. The tool description does not explain any of these parameters, leaving the agent to infer their meaning from context. This is a significant 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 explicitly states that the tool returns investment portfolios from a connection, listing specific asset types (FIIs, stocks, ETFs, fixed income, mutual funds, retirement, COE) and the data fields per row. It clearly distinguishes from sibling tools like openfinance_list_investment_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 the fallback behavior when investments are not enabled, but does not provide explicit guidance on when to use this tool versus alternatives, such as openfinance_list_investment_transactions. The context is implied but not directly stated.

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, idempotentHint, and destructiveHint, establishing safety. The description adds value by detailing the return structure (quantity, value, netAmount, brokerageNumber, itemized expenses) and bulk support, though it doesn't mention pagination behavior despite page/page_size parameters existing.

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

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

The description is concise (two sentences plus bulk note) and front-loaded with core purpose, avoiding any superfluous content. Every sentence contributes useful information.

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

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

Given no output schema, the description provides good contextual detail on return fields and prerequisites. However, it could be more complete by explaining pagination or default ordering, but overall it is adequate for a list tool.

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

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

Schema description coverage is 0% so description must compensate. It explains investment_id (required) and mentions bulk support for investment_ids, but does not clarify page or page_size parameters, leaving a gap for agent 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 movement history for a specific investment position, listing transaction types (BUY/SELL/TAX etc.). It distinguishes itself from sibling openfinance_list_investments by advising use after that tool, and mentions bulk support, 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 explicitly instructs to use after openfinance_list_investments to obtain investment_id, providing a clear prerequisite. However, it does not contrast with similar sibling tools like openfinance_list_transactions, missing an explicit when-not or alternative scenario.

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 detail beyond annotations: sequential execution with rate-limit spacing, return format '{ results, errors }' per connection. Annotations already confirm readOnlyHint and idempotentHint, so the description enhances transparency 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?

Two sentences pack all essential information: purpose, endpoint, parameter usage with two cases, and return format. No redundant 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?

For a tool with one optional parameter and no output schema, the description covers all necessary aspects: what it does, how to use the parameter, what happens when omitted, and the response structure. It is fully self-contained.

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 provides no parameter descriptions (0% coverage), so the description fully compensates by explaining that 'items' is an array of connection selectors (item_id uuid, connector_id, or connector_name). This adds complete semantic meaning.

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

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

The description clearly states the tool lists loan contracts per bank connection, using the verb 'lists' and resource 'loan contracts'. It distinguishes from sibling list tools (e.g., list_accounts, list_transactions) by specifying the loan-specific endpoint '/loans' and the connection-based retrieval.

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

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

The description provides explicit usage guidance: pass 'items' for specific connections, omit for all linked banks. It does not explicitly name sibling tools as alternatives, but the context of the sibling list (e.g., list_accounts) is implied. A slight improvement would be direct references to other list operations.

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

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

Beyond annotations (readOnly, idempotent, non-destructive), it details credit card metadata sparsity, PENDING/POSTED variability per connector, error returns (not throwing), provider incidents, and pagination ceiling with truncated flag. Comprehensive behavioral disclosure.

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

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

The description is lengthy but well-structured, front-loading the main purpose and covering many edge cases. Each sentence adds value, though it could benefit from more visual structuring. Still appropriate for 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?

Given the tool's complexity (8 parameters, credit card nuances, pagination, detail levels, provider incidents, error states), the description is very complete. It even explains the response structure (account echo, provider_incident block) and what to do when total is 0. No output schema but fully compensates.

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% parameter descriptions; the description compensates fully by explaining each parameter's format (ISO dates), semantics (search_queries substring match with OR), enumeration options (detail), pagination meanings, and bulk support (account_ids). 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 tool returns transactions for bank accounts (BANK or CREDIT type), distinguishing it from siblings like openfinance_list_credit_card_bills. It specifies the scope and resource, 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?

Provides explicit guidance: when to use for credit card itemized transactions vs using bills for totals, pagination modes (omit page for auto-pagination vs explicit manual), detail levels, and handling bulk queries. Also warns against summing by billId.

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

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

Annotations already mark it as readOnly, idempotent, and non-destructive. The description adds significant behavioral details beyond annotations: it internally resolves accounts, caps at 5000 transactions per account with a truncated flag, and warns about provider_incident blocks that may indicate incomplete data. 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 lengthy but every sentence adds value. It is front-loaded with the core purpose and then details parameters and behaviors. It could be slightly more structured (e.g., bullet points for parameter explanations), but it remains clear and free of 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?

Given no output schema, the description thoroughly explains return structure: compact summary with totals, monthly evolution, top expenses/revenues, per-account breakdown, and raw mode with optional enrichment. It covers truncation and provider incidents. All 7 parameters are explained. The tool is complex, and the description is complete for an AI agent to understand usage.

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

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

Schema description coverage is 0%, so the description carries full burden. It explains all 7 parameters: item (various identifier types, omit for all), from/to (ISO dates), granularity (monthly vs raw with effect on output), detail (compact/rich/raw for row enrichment), type (BANK/CREDIT filter), and top_n (implied). This fully compensates for the lack of schema descriptions.

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

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

The description clearly states it performs consolidated cash-flow analysis for a whole bank connection in one call, explicitly distinguishing it from needing to call openfinance_list_accounts first or use account IDs. It specifies the resource (transactions by item/connection) and the verb (analyze/list), and the name 'list_transactions_by_item' contrasts with sibling 'list_transactions' which likely requires per-account calls.

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

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

The description provides explicit guidance on when to use the tool (e.g., for anual/mensal analysis, cash flow, major expenses) and when to choose between granularity and detail options. It explicitly says not to call list_accounts first. However, it lacks a direct comparison to the sibling 'openfinance_list_transactions', which could further clarify usage boundaries.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint false. Description adds 'LIVE operational status', 'separate from your own connection', and explains return fields (global indicator, degraded components, incidents, affected banks). 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?

Well-structured: starts with purpose, then usage context, then return details. Each sentence adds value. Slightly long but efficient for the detail provided.

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

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

With no output schema and no parameters, the description fully explains what the tool returns (global indicator, degraded components, incidents, affected banks) and when to use it. 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?

No parameters; description does not need to add parameter meaning. Schema coverage is 100% (none). 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?

Description clearly states the tool checks the live operational status of the Open Finance provider, distinguishes from sibling tool openfinance_get_item_status by specifying it checks provider health separately. 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 tells when to use: when data looks incomplete or stale despite connection showing updated, and how it helps differentiate provider-side vs connection issues. Mentions return values and contrast with sibling 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?

Adds behavioral details beyond annotations: keywords[] is required and returns a hint if omitted, caveat for non-Open-Finance connectors, plan filtering. 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?

Single paragraph contains all necessary information, front-loaded with purpose. Could be slightly more structured (e.g., bullet points), but is compact and clear without waste.

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 purpose, usage, parameters, behavioral traits, and plan restrictions. No output schema exists, but description provides sufficient information for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains keywords[] as an array of strings (with examples) and states it's required, and explains include_accounts=true adds accounts. This fully clarifies parameter 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 it searches bank connectors by name, returns connector id, access type, audience, linked connections, accounts, and connect_url. It distinguishes itself from siblings like 'connect' and 'marketplace' by specifying its role as a pre-connection search 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?

Explicitly says 'Call this BEFORE connecting to hand the user a one-click link to the right bank,' providing direct usage context. It mentions honoring the user's plan and surfacing caveats for non-Open-Finance connectors, guiding the agent to recommend Open Finance when possible. Does not explicitly state when not to use, but context is sufficient.

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

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

Beyond annotations (all false), the description discloses critical behaviors: it overrides automatic categorization, creates a Category Rule for future similar transactions, and describes batch semantics including per-item errors. This adds significant value over 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 comprehensive but slightly lengthy; however, every sentence adds useful context. It front-loads the purpose and is well-structured, earning a high score.

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

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

Despite lacking an output schema, the description provides the return structure, side effects (Category Rule creation), and error handling details. It gives a complete picture for understanding tool behavior.

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

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

With 0% schema description coverage, the description fully compensates by explaining the 'items' parameter structure, the meaning of transaction_id and category_id, and their provenance from other tools. It also details the return shape and error handling.

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 corrects the category of one or more transactions, referencing the HTTP method and endpoint. It distinguishes from sibling tools by specifying how to obtain IDs from openfinance_list_transactions and openfinance_list_categories.

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

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

The description provides clear guidance on when to use the tool: to fix miscategorized transactions and improve future categorization. It explains where to get necessary IDs but lacks explicit instructions on when not to use or alternatives.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description does not add behavioral context beyond stating the purpose. With annotations covering key traits, this is adequate but lacks extra detail like side effects or response behavior.

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

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

The description is a single sentence that front-loads the purpose. It is concise, but could benefit from a clearer separation of purpose and usage instructions. Nonetheless, it is efficient.

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

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

Given the simple nature of the tool (feedback) and the presence of annotations, the description is minimally complete. However, it lacks parameter details and does not explain what happens after submission, which could confuse an agent.

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

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

Schema description coverage is 0%, and the description only mentions 'conversation array' without explaining the purpose of the 'message' (required) or 'context' parameters. This is insufficient for correct invocation, as the agent must guess the role of each field.

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

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

The description clearly states the tool is for reporting bugs, missing features, or sending feedback. It specifies to include the conversation array. This distinguishes it from all sibling tools, which are primarily for authentication, finance, or system info.

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 specific usage instruction ('Include the conversation array with recent messages for reproduction'), but does not provide when-to-use or when-not-to-use context, nor does it mention alternative tools. The usage is implied but not explicit.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, meaning the description only needs to add specific context. It adds what versions are shown but nothing beyond that. For a simple readonly tool, this is sufficient but not exceptional.

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

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

A single, complete sentence with no filler. Every word is necessary and the information is front-loaded.

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, simple annotations, and no output schema, the description is entirely sufficient. It fully covers what the tool does without needing additional return value explanation.

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 baseline is 4. The description adds no parameter details, but none are needed. This score reflects the appropriate baseline.

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

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

The description clearly specifies the tool's action ('Show') and the exact resources ('current MCP platform and adapter versions'). It is a specific verb+resource that distinguishes it from all listed sibling tools.

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

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

The description implicitly communicates the usage context: call this when you need to know current platform and adapter versions. No explicit when-not-to-use or alternatives, but given the tool's simplicity and uniqueness among siblings, it's adequate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds value by specifying the returned content (MCPs, status, counts), which is useful 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 a single, front-loaded sentence that conveys all necessary information without extraneous words. Every part of the 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?

Given no parameters, no output schema, and comprehensive annotations, the description is complete. It clearly explains what the tool returns, which is sufficient for an agent to use it correctly.

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

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

The tool has 0 parameters, and the schema description coverage is 100%. According to the rubric, this gives a baseline of 3. The description does not add any parameter information since there are none, so it meets the baseline.

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 with specific details: installed MCPs, connection status, and catalog tool counts. It uses a specific verb ('Returns') and resource ('current toolkit state'), distinguishing it from sibling tools that perform specific 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?

While no explicit when/when-not or alternatives are given, the context is clear: this is an overview tool for retrieving state, distinct from action-oriented siblings. The simplicity of the tool makes extensive guidelines unnecessary.

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