Banco Mercantil MCP

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

Description matches annotations (idempotentHint true, not destructive). Explains behavior for both call modes, though could mention if token validation fails (e.g., expired).

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 context (MCP.AI for IDE agents). Each sentence serves a purpose, but could be tightened slightly.

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

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

Adequately covers the simple tool with one optional parameter and no output schema. Missing details on error handling but good for a login 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?

Adds crucial context beyond the bare schema: explains 'token' is a JWT access token and how it's used, compensating for 0% schema description coverage.

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

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

Clearly states it handles authentication via browser login and JWT token, distinguishing it from siblings like 'connect' with specific token-based workflow.

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

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

Explicitly describes two usage scenarios: permanent via config header or session-only by passing token, and explains when to call with no args to get the 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?

Beyond annotations (readOnly, idempotent), description explains state-dependent behavior (e.g., empty pending array when authenticated). Adds value 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 sentences with no waste. Front-loaded with main purpose, then elaborates on state-specific details. 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 simple status tool with no parameters and annotations covering safety, the description sufficiently explains return values. Could mention exact response structure (JSON), but the examples cover key states.

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, so description focuses on output semantics. Explains return values in different scenarios, which compensates for lack of output schema. Baseline 4 for zero 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?

Clearly states the tool returns connection status and URLs, with specific examples of different states. Distinguishes from siblings like 'authenticate' by focusing on status rather than authentication flow.

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

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

Describes when to expect certain outputs (all connected vs missing credentials), providing context for use. Does not explicitly mention when not to use or list alternatives, but the guidance 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 reveals critical behavioral details beyond the minimal annotations: invoke works even when the MCP is not installed and runs one-off without adding to the toolkit; missing credentials return a connect link; empty wallet triggers a checkout/top-up link; and writes require workspace owner/admin. These are not provided by the annotations and are essential for correct invocation.

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

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

The description is a single dense paragraph that is longer than typical, but each sentence adds meaningful information about flows, permissions, and the prompt library. It lacks bullet points or paragraph breaks, harming scanability, yet the length is justified by the tool's 14-action 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?

For a tool with 14 actions, 23 parameters, and no output schema, the description covers an extensive amount: the end-to-end search→describe→invoke flow, install vs invoke trade-offs, auth/payment edge cases, permission requirements, and an entire separate prompt-library section. The only minor gap is the undocumented `resume` action, but overall the description is remarkably complete.

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

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

The description explains the meaning of the `action` enum values and clarifies the role of `tool_id`, `arguments`, and `prompt_vars` in context. However, with 23 parameters and 0% schema coverage, many parameters (e.g., `immediate`, `tier_slug`, `report_context`, `conversation`, `cancel_reason`) remain undefined, leaving the agent to infer their purpose. The description does not fully compensate for the schema's silence.

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

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

The description clearly identifies the tool as the mcp.ai marketplace – the in-platform catalog of MCPs/tools and the way to run them. It specifies the resource (catalog and prompt library) and the distinct actions (search, describe, invoke, install, etc.), which separates it 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?

The description provides explicit guidance on when to use each action: the core flow (search → describe → invoke), 'prefer invoke for single/occasional use', 'Use install only to make an MCP PERMANENT', and 'request_mcp asks us to build a NEW MCP when nothing fits'. It also states permission requirements for writes, enabling clear 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?

The description explains the destructive behavior (revoking consent, deleting data) which aligns with the annotations' destructiveHint=true. It adds context beyond annotations by specifying what happens to the data and that a reconnection URL is returned.

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 cover the action, consequences, and return value. No excessive wording; 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?

For a simple destructive tool with annotations and one parameter, the description covers the main effect and return value but fails to explain the required 'item' parameter. This incomplete parameter guidance lowers the score.

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 one parameter 'item' with no description and 0% coverage. The description only says 'for a specific bank' but does not clarify that 'item' is the bank identifier or what format/values it should take. This is a significant gap given 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 revokes consent and deletes connection data for a specific bank. It also mentions the returned add_connection_url. This verb+resource combination is distinct from sibling tools like connect or 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 indicates when to use (to disconnect a bank) and implies that after use the bank's data is no longer available. It also suggests reconnection via the returned URL. However, it does not explicitly list when not to use or alternatives, though siblings don't provide obvious 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 (which indicate a non-read-only, non-destructive operation), the description details the PATCH-then-poll mechanism, 60s timeout, return object with status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, and timed_out flag. 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 comprehensive and well-structured, front-loading the core action and then detailing usage, parameters, return values, and edge cases. While slightly long, every sentence adds value, and it avoids redundancy.

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

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

Given the 2 parameters and no output schema, the description covers all needed context: return format, error states (needs_action with reconnect_url), timeout handling, and cross-reference to openfinance_get_item_status. It is fully complete for an agent to select and 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?

Despite 0% schema description coverage, the description fully explains both parameters: 'wait' (true = wait and poll, false = fire-and-forget) and 'items' (array of selectors: item_id, connector_id, connector_name, or custom_label; omit to sync all). This compensates completely for missing schema descriptions.

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

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

The description clearly states 'Forces the bank to re-sync one or more connections NOW and WAITS for it to finish', using a specific verb (force sync) and resource (connections). It distinguishes from sibling tools like openfinance_list_connections or openfinance_get_item_status by emphasizing the refresh action.

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

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

Explicitly describes when to use: 'Use this when a balance or transaction list looks stale'. Explains that it pulls fresh data without disconnecting, and provides guidance on omitting items to sync all, and setting wait: false for fire-and-forget. Also directs to openfinance_get_item_status for timed-out results.

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

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

Discloses key behaviors beyond annotations: potential BALANCE_FETCH_ERROR for CREDIT accounts, degradation to last-synced balance with realtime:false and warnings when upstream is unavailable. No contradiction with annotations (readOnlyHint, idempotentHint).

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?

Concise, front-loaded with endpoint and parameter, then covers edge cases efficiently. No superfluous sentences; 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 lacking an output schema, the description gives the response shape ({ results, errors }) and handles error states. For a single-parameter tool, this is comprehensive.

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

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

Schema coverage is 0%, so description must compensate. It explains that account_ids is an array of 1-50 items, adding a constraint not in schema. Lacks explicit format of each ID (e.g., string pattern), but overall conveys meaning adequately.

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

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

The description clearly states 'Returns real-time balance payload per account id' and specifies the endpoint, making the tool's purpose explicit. It distinguishes from sibling tools like openfinance_get_accounts_detail or openfinance_list_accounts by focusing on balance retrieval.

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

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

Provides explicit guidance: 'Pass account_ids as an array (1–50)' and explains when warnings appear (CREDIT accounts, temporary unavailability) versus errors, helping the agent decide when to use this tool and what to expect.

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: batch response shape {results, errors} and the provider_incident warning about unreliable limits/balances. This goes beyond the structured annotations.

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

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

The description is two sentences, front-loaded with the core functionality, and every sentence adds necessary information. No redundant or vague phrasing.

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

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

Given no output schema, the description explains the batch response structure and the provider_incident edge case. It covers constraints and reliability warnings. It could mention creditData fields briefly, but the tool's purpose is adequately captured.

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 provides minimal info (account_ids as array of strings). The description adds the critical constraint of array size (1–50), which is not in the schema. With 0% schema description coverage, the description meaningfully compensates.

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

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

The description clearly states the tool returns full account objects with extended creditData for given IDs via GET /accounts/:id with batch processing. However, it does not explicitly differentiate from siblings like openfinance_list_accounts, though the verb 'detail' implies a more specific scope.

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 account_ids as an array of 1–50 items. It also warns about the provider_incident block and unreliable data. However, it does not specify when to use this tool versus alternatives like list_accounts.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds valuable context: does NOT return individual transactions, batch shape, Pluggy missing status field, and Brazilian Open Finance payment semantics. However, could mention the read-only nature explicitly.

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

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

Description is relatively long but well-structured with bullet points and front-loaded with main purpose. Every sentence adds value with minimal redundancy.

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

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

Given no output schema, description fully covers return fields (financeCharges, payments with subfields), batch shape, and domain-specific knowledge about Brazilian Open Finance payment behavior. Meets all needs for a complex data retrieval 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?

Only one parameter bill_ids with no schema description. Description explains it's an array and instructs to use openfinance_list_credit_card_bills first to discover ids, which adds 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?

Description clearly states 'Returns bill-level detail for one or more credit card bills by id' and distinguishes from sibling tool openfinance_list_transactions, which returns individual transactions. The verb 'Returns' and resource 'bill-level detail' 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 states when to use this tool vs alternatives: 'to get itemized credit card transactions, use openfinance_list_transactions'. Also advises to first use openfinance_list_credit_card_bills to discover ids, and warns not to reconstruct bill total by summing transactions.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint. Description adds behavioral context such as returning reconnect_url, executionStatus, and connector metadata, and explains the difference in output for single vs all banks. 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 concise and front-loaded with the primary purpose. It conveys essential information in a few sentences without unnecessary verbosity, though it could be slightly more structured with bullet points.

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 read-only tool with no output schema and optional parameters, the description covers the main use cases (single, all, bulk) and mentions key return fields. It lacks edge case handling but is sufficient for typical usage.

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

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

Schema coverage is 0%, but description compensates by explaining the role of each parameter: omit for all, pass 'item' for single, and 'item_ids' for bulk. This adds clear semantics beyond the bare schema.

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

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

The description clearly states 'Returns the current status of a bank connection' with specific status examples. It distinguishes between single and bulk modes, and the tool is distinct from siblings like openfinance_list_connections which return lists rather than status.

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

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

The description explicitly explains when to omit or pass the 'item' parameter for all banks vs single bank, and mentions bulk support via item_ids. However, it does not provide explicit when-not-to-use guidance or compare to 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 readOnly, idempotent, not destructive. Description adds that it returns a batch shape with results and errors, and implies no side effects. Provides HTTP method and path.

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, dense with information including field list. Slightly verbose but front-loaded with purpose. Could be more concise by summarizing fields, but still 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 annotations and no output schema, the description covers purpose, usage context, parameter details, and output shape. Complete for the tool's role.

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

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

With 0% schema coverage, the description compensates by explaining loan_ids is an array of 1-50 strings and mentioning the output shape { results, errors }. Adds useful context 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 full loan contract detail by ID, lists specific fields, and distinguishes from sibling openfinance_list_loans by specifying when to use it.

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 for deep-dive, and provides parameter constraints (array of 1-50 IDs). Does not explicitly mention 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 (readOnlyHint=true, destructiveHint=false), description discloses critical behaviors: credit balance is connector-dependent, provider_incident means unreliable data, identity_notice for joint accounts, bulk support via item_ids. 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?

Description is long but front-loads the main purpose. Could be split into shorter paragraphs or bullet points for clarity. However, every sentence adds value, and the structure is logical.

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

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

Given no output schema, the description covers return fields, special notices (provider_incident, identity_notice), bulk support, and cross-references sibling tools. It is nearly complete for an agent to use correctly.

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

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

Schema has 0% coverage, so description fully compensates. Explains each parameter: 'item' for single bank, 'item_ids' for bulk, 'type' for filtering. Adds meaning by describing the effect of omitting 'item' and the behavior of bulk execution.

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

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

The description uses specific verbs ('Returns accounts for a bank connection') and distinct resource types (BANK, CREDIT). It clearly distinguishes the tool from siblings like openfinance_list_transactions or openfinance_list_credit_card_bills by stating what it retrieves and when to use others.

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: use 'item' for a single bank, omit for all banks. Names alternative tool openfinance_list_credit_card_bills for standardized billing amounts. Includes context about provider_incident and identity_notice, telling the agent how to handle edge cases.

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 indicates caching behavior ('cached for the adapter session') and mentions 'single aggregated response — no batch ids,' which adds context beyond the readOnlyHint and idempotentHint annotations. No contradictions.

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

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

Two sentences, no wasted words. The main purpose is front-loaded, followed by structured information about the output. Efficient and 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?

For a read-only, no-parameter tool with annotations covering safety, the description provides all necessary context: what it returns, caching, output structure, and a usage hint linking to another tool.

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

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

No parameters exist, and schema coverage is 100%. The description adds value by explaining the output fields and their relevance to another tool, satisfying the baseline for zero-parameter tools.

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

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

The description clearly states it returns the transaction category taxonomy, identifies the API endpoint, and describes the structure of each entry. It distinguishes itself from sibling tools by focusing on 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 mentions that the category id is used by another tool (openfinance_update_transaction_category), providing context for when to use this tool. However, it doesn't explicitly state when not to use it.

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 readOnlyHint=true, so no mutation. The description adds that reconnect_url opens in UPDATE mode but does not consume a slot and does not require disconnection. This is useful behavioral context beyond annotations, though error states are not covered.

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 focused paragraph that front-loads the return fields and then explains the reconnect_url. It is efficient but slightly dense; could benefit from breaking into bullet points.

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

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

Given no parameters and no output schema, the description covers the tool's output and key usage (reconnect behavior). It lacks information on pagination or errors, but for a simple read-only list, it is reasonably complete.

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

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

No parameters exist, so schema coverage is 100%. The description adds value by detailing the returned fields, which is appropriate for a parameterless tool.

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

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

The description clearly states it returns saved bank connections with specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes from sibling list tools by focusing on connections and their reconnect capability.

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

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

The description explains when to use the reconnect_url (for re-authentication needs like MFA, LOGIN_ERROR, stale data) and notes it does not consume a slot or require disconnection. It does not explicitly contrast with sibling tools, but the context is clear.

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

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

The description extensively details behavioral traits not covered by annotations: derived payment_status logic, payment landing rules, connector asymmetry, warning behavior, and open_bill confidence levels. No contradiction with annotations.

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

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

The description is lengthy yet structured with clear section headers, making it skimmable. While dense, every sentence adds value for the complex domain; a bit more conciseness could improve 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?

Given the tool's complexity (5 params, no output schema), the description thoroughly covers response structure, derived fields, edge cases, and warnings. Missing page/page_size details are minor relative to the overall 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?

The description adds meaning for account_id, account_ids, and include_open_bill, explaining their roles and defaults. However, page and page_size are not described despite 0% schema coverage, leaving a gap for these common but undocumented 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 it returns closed credit card bills for a credit-type account, listing specific fields. It distinguishes from siblings like openfinance_get_credit_card_bill (singular) and openfinance_list_transactions (for items), fulfilling the verb+resource+scope criteria.

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

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

The description explicitly advises when to use alternatives (e.g., 'To see itemized purchases/charges, use openfinance_list_transactions...') and when not to (e.g., 'do NOT reconstruct a bill total by summing transactions by billId'). It also explains opt-in behavior for open_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?

Description adds significant behavioral context beyond annotations: returns warning instead of throwing errors, details data integrity cross-checking for mass zeroing, and flags suspect rows. No contradiction with readOnlyHint=true.

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

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

The description is dense but well-structured with clear sections (returns, error handling, data integrity, bulk support). It could be slightly more concise, 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?

Given the complexity (6 parameters, no output schema), the description covers key behaviors: return format, error handling, data integrity warnings, and bulk execution. Minor omissions like parameter descriptions keep it from being fully complete.

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

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

The description mentions bulk support with item_ids but does not explain other parameters (item, page, type, page_size). With 0% schema coverage, the description should detail parameter meanings, but it leaves 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 returns the investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). It distinguishes this tool from siblings like list_investment_transactions by focusing on portfolio data vs 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 this tool is for retrieving investment portfolios and includes notes on error handling and data integrity. However, it does not explicitly state when to use this tool over alternatives like list_investment_transactions or when not to use it (e.g., if only transactions needed).

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) already indicate safe read behavior. Description adds value by detailing the types of transactions returned and specific fields (e.g., expenses breakdown), plus bulk execution support. No contradictions.

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

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

Three sentences: first defines purpose and output, second gives usage context, third mentions bulk. No redundant words. Front-loaded with essential 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?

Description covers the core functionality, return fields, and usage dependency. However, it does not explicitly mention pagination behavior (page/page_size) which is present in the schema, though the schema itself provides those parameters. Overall sufficient for a read-only list tool with annotations.

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

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

Schema description coverage is 0% (no descriptions in schema). Description partially explains investment_id (context on how to get it) and mentions investment_ids for bulk, but does not describe page and page_size. With 4 parameters, this leaves significant 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?

Description clearly states the tool returns movement history for a specific investment position, listing transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER) and detailed fields. It distinguishes from siblings like openfinance_list_investments by mentioning to use after that tool, and from general transaction tools by specifying investment context.

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

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

Explicitly advises to use after openfinance_list_investments to obtain the investment_id, and mentions bulk support via investment_ids. While it doesn't explicitly state when not to use or name alternatives, the context and sibling list make alternatives inferrable.

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 context beyond annotations: sequential querying with rate-limit spacing and return format {results, errors} per connection. Annotations already indicate readOnly and idempotent.

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

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

Two sentences, front-loaded with purpose, no wasted words. Efficiently conveys 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?

Given one parameter, no output schema, and comprehensive annotations, the description is fully adequate. Covers behavior, parameters, and response structure.

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 compensates by explaining the `items` parameter as an array of connection selectors (item_id, connector_id, or connector_name) and its semantics.

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

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

The description clearly states it lists loan contracts per bank connection using GET /loans. It distinguishes from sibling tools like openfinance_get_loan_detail by specifying it lists across 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?

Provides explicit guidance on using `items` for specific connections or omitting for all linked banks. Mentions sequential queries with rate-limit spacing, but lacks explicit 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 declare readOnlyHint=true and idempotentHint=true, but the description adds extensive behavioral context: per-connector variability for CREDIT pending/posted, billId being a sparse hint, auto-pagination up to 5000 items, error handling (returns error object instead of throwing), provider incident block, and detail level effects. This goes far 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 clear sections for pagination, detail control, credit card specifics, and bulk support. It front-loads the core purpose and adds value in every paragraph. While not 'concise' in length, it is efficiently organized given the complexity, earning a 4 rather than 5 due to slight verbosity.

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

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

Given the complexity (8 parameters, no output schema, annotations present), the description is exceptionally complete. It covers response structure (account echo block), provider incidents, cross-tool references (openfinance_list_credit_card_bills, openfinance_list_accounts, openfinance_get_item_status), and edge cases (truncated, error handling). No 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?

Schema description coverage is 0%, but the description compensates fully. It explains account_id (required), account_ids (bulk), from/to (ISO YYYY-MM-DD), search_queries (OR semantics, case/accent-insensitive), page/page_size (pagination modes), and detail (compact/rich/raw with specific behaviors and token costs). Every parameter is semantically clarified.

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 transactions for bank accounts (BANK or CREDIT type). It specifies the resource and distinguishes it from sibling tools like openfinance_list_credit_card_bills, stating that for CREDIT accounts this is the ONLY way to get itemized transactions. The purpose is unambiguous and well-defined.

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 provides when-to-use guidance: it is the only way for credit card transactions, warns against using billId to reconstruct totals (referencing openfinance_list_credit_card_bills for source of truth), explains the pending vs posted behavior per connector, and details pagination modes (auto vs manual). It also advises checking connection health if total is zero for CREDIT accounts. This is comprehensive.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds critical behavioral details: the 5000-transaction cap per account with a truncation flag, the provider_incident block for external issues, and the fan-out behavior across accounts. It also explains the effect of different granularity and detail levels on output.

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 paragraphs and examples, and every sentence adds value. It is slightly verbose but not wasteful, fitting for a complex tool with many options. The front-loading of the core purpose is 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?

Despite lacking an output schema, the description thoroughly outlines what the agent can expect: total entradas/saídas, monthly evolution, top expenses/income, per-account breakdown, optional raw rows, and incident/truncation flags. This covers the key usage context for an agent selecting 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?

With 0% schema coverage, the description compensates well by explaining most parameters: 'item' (accepts connector_id, connector_name, item_id), 'from/to' (ISO dates), 'granularity' (monthly vs raw with compact summary details), 'type' (BANK or CREDIT), 'detail' (compact, rich, raw with enrichment info), and 'item_ids' for batch. The 'top_n' parameter is implied but not explicitly defined, leaving a minor gap.

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

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

The description clearly states it's for 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call', and distinguishes from siblings by noting it resolves accounts internally, avoiding the need for separate calls to openfinance_list_accounts. This sets it apart from related tools 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 provides explicit usage contexts such as 'análise anual/mensal', 'fluxo de caixa', etc., and explains when to omit the 'item' parameter for all banks. It also warns about truncation and provider incidents. However, it does not explicitly state when to avoid this tool in favor of a sibling like openfinance_list_transactions for per-account raw data.

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

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

Annotations already provide readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral context: it checks a public status page, returns a global indicator (none/minor/major/critical), degraded components, open incidents, and flags affecting connected banks. No contradiction with annotations.

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

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

The description is relatively long but every sentence adds value, explaining purpose, usage, and output. It is front-loaded with the main action. Could be slightly condensed but remains clear and comprehensive.

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

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

Given the tool has no output schema, the description thoroughly explains the return fields and the problem scenario it addresses. It covers the global indicator, degraded components, incidents, and connected-bank-specific flags, making it complete for an agent to understand and use.

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

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

The input schema has zero parameters, so baseline is 4. The description adds meaning by detailing the return values (global indicator, components, incidents, your_banks_affected), which compensates for the absence of output schema. No parameter information is needed.

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

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

The description explicitly states it checks the LIVE operational status of the Open Finance provider, contrasting with the sibling openfinance_get_item_status. The verb 'checks' and resource 'provider status' are specific, and the tool is clearly differentiated from other connection-oriented 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 detailed when-to-use guidance: when data looks incomplete or stale despite a connection showing UPDATED. It also explains what the tool reveals (upstream outage, specific bank incidents) and explicitly distinguishes it from openfinance_get_item_status, giving the agent clear criteria for selection.

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

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

Annotations indicate read-only, idempotent, non-destructive. Description adds rich behavior: returns a ready connect_url, honors user plan (PF hides PJ), and surface caveats for credential connectors. No contradiction with annotations; instead extends them.

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

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

Single dense paragraph conveys all necessary information without redundancy. Every sentence adds value, though breaking into bullet points could improve readability. Not overly long.

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

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

Given no output schema, description details expected return fields (connector id, access, audience, linked connections, accounts, connect_url, caveat) and plan behavior. Coverage is complete for a search 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 coverage is 0%, but description fully compensates: explains 'keywords' as array of strings with examples, and 'include_accounts' as boolean to include accounts. Provides meaning beyond schema names.

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

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

The description clearly states the tool searches bank connectors by name, specifies the returned fields (connector id, access, audience, linked connections, connect_url), and distinguishes its purpose as a pre-connect search tool, setting it apart from siblings like 'connect' or '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?

Explicitly states it should be called BEFORE connecting and that keywords[] is required (without it returns a hint). Provides guidance on surfacing caveats for non-Open-Finance connectors. Does not explicitly name alternative tools for when not to use, but context is clear.

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

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

The description goes beyond annotations by disclosing the important behavioral trait that recategorizing creates a Category Rule, affecting future transactions. It also explains batch behavior with per-item errors. This provides agents with critical context for safe and correct invocation.

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 HTTP method, then efficiently covers side effects, batch behavior, and return shape. Every sentence adds value with no redundancy or fluff.

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

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

Despite no output schema, the description explicitly details the return format ({ updated, results, errors }) and error handling (per-item errors do not fail the whole batch). The tool's complexity (batch update with side effects) is fully addressed, making it 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?

Although schema description coverage is 0%, the description explains the structure of the 'items' parameter (array of { transaction_id, category_id }) and tells agents where to obtain these IDs from sibling tools. This adds significant meaning beyond the raw schema, though it could have provided more detail on constraints (e.g., required fields).

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 transactions (PATCH /transactions/:id). It distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories by referencing how to obtain IDs, making the purpose 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 explains when to use the tool (to fix miscategorized transactions and improve categorization) and provides context about the side effect (creating Category Rules). It references related tools for getting IDs, giving practical guidance. However, it does not explicitly state when not to use it or compare to alternatives, which would have earned a 5.

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 it is idempotent and non-destructive. The description adds no further behavioral details beyond purpose.

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

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

Two sentences, front-loaded with purpose, no superfluous content.

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 and one usage hint, but lacks return value information and does not explain the required 'message' parameter fully. Adequate 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 coverage is 0%. The description hints at 'message' for feedback and 'conversation' for reproduction, but ignores the 'context' parameter, providing incomplete 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 clearly states the tool reports bugs, missing features, or feedback. This is distinct from sibling tools which are primarily 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, but does not specify when to use vs. alternatives or 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 indicate readOnlyHint=true and idempotentHint=true. The description confirms it's a read operation but adds no new behavioral details beyond what annotations provide.

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

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

Single sentence that is concise and front-loaded with the action. No unnecessary words or 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?

Given no output schema, the description could mention the structure or format of the version info, but it is otherwise complete for a simple retrieval tool. Annotations cover safety traits.

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

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

There are no parameters, so schema coverage is 100%. The description does not need to add parameter info; baseline for zero 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 clearly states it shows current MCP platform and adapter versions, using a specific verb and resource. It distinguishes itself from sibling tools, none of which claim to show version 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 implies usage context (checking versions) but does not explicitly state when to use or exclude alternatives. For a simple version tool, this is sufficient.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds context beyond annotations by specifying the exact information returned (installed MCPs, statuses, accounts, tool counts), which helps the agent anticipate the output even without an output schema.

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

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

The description is a single, well-structured sentence that front-loads the action ('Returns the current toolkit state') and then lists the key data points. No filler or redundant information, making it highly efficient.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description fully covers what the tool does and what it returns. It is complete enough for an agent to select and invoke this tool correctly without additional context.

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

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

The tool has zero parameters, so the description needs no parameter details. Per the rubric, 0 params earns a baseline of 4, and the description correctly focuses on the return payload rather than input semantics.

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

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

The description uses the specific verb 'Returns' and clearly specifies the resource ('current toolkit state') along with detailed components: installed MCPs, connection status, connected accounts, and catalog tool counts. This distinguishes it from sibling tools, which focus on finance operations or authentication.

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

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

The description implies its use for checking toolkit status but does not explicitly state when to use this tool versus alternatives. It provides context (what it returns) but no explicit exclusions or alternatives, making it adequate but not clearly curated for selection guidance.

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