Sicredi MCP

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

The description discloses behavioral details beyond annotations: e.g., that config-based authentication yields a permanent connection, while token pasting is session-only. It does not contradict annotations; idempotentHint is consistent with repeated token calls.

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 key information front-loaded. It is slightly verbose but every sentence serves a purpose in explaining the authentication workflow.

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

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

The description covers all relevant aspects of the tool's behavior for a simple authentication tool. It lacks explicit mention of the return value on success, but the overall completeness is high given the tool's simplicity and lack of output schema.

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

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

The schema only defines a single optional 'token' parameter with no description. The description explains that 'token' is a JWT access token and that omitting it returns a login link, adding essential semantic 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?

The description clearly states the tool's purpose: authenticating users for IDE agents. It specifies three distinct modes of operation (config-based, session token, login link) and distinguishes it from sibling tools, which are unrelated.

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 mode: config for permanent, pasting token for session, or no args for login link. It also instructs the agent on how to call the tool in each case.

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

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

The description adds significant context beyond annotations, detailing return values and conditions (authenticated:true, pending[], connect_url), fully disclosing behavior 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 extremely concise, front-loading the main purpose in the first sentence and adding necessary detail in the second, 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?

While the description covers two main scenarios, it does not address partial connection states or provide a complete response structure, but is sufficient for a simple parameterless 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%, so the description appropriately focuses on return behavior without needing parameter details.

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

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

The description clearly states the tool returns connection status and URLs, and specifies behaviors for different states (all connected vs missing credentials), making the purpose unambiguous.

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

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

The description provides context on when to call based on connection state, but does not explicitly compare to sibling tools like 'authenticate' or 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?

The description reveals critical behaviors not in annotations: invoke works even when the MCP is not installed (one-off execution), returns connect/checkout links when credentials or payment are needed, and writes require workspace owner/admin. It also explains that search/describe flag installation status, and details the prompt library behavior. No contradiction with annotations.

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

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

The description is a single dense paragraph of approximately 250 words covering 14 actions. It is information-rich with every sentence contributing, but the lack of structure (bullets, sections) makes it hard to scan. It could be more concise and better organized for quick reference.

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

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

Given 23 parameters, no output schema, and 14 actions, the description covers most key context: the full action flow, billing/install nuances, permission requirements, and the prompt library. It does not explicitly mention the 'resume' action or describe the return schema of describe/invoke, but overall it is substantially complete for a tool of this complexity.

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

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

Schema has 0% description coverage, so the description must compensate. It explains the action parameter's enum values in detail and clarifies the roles of tool_id, mcp_id, prompt_slug, and prompt_vars. However, many parameters (limit, query, immediate, tier_slug, conversation, etc.) are not individually explained, leaving some ambiguity.

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

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

The description opens with a clear definition: 'The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' This states both the resource (marketplace) and the verbs (search, describe, invoke, install), clearly distinguishing it from sibling openfinance tools. It then enumerates the core actions, making its multi-action purpose evident.

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

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

Explicit guidance is provided: 'Core flow: action=search discovers MCPs by intent → describe returns one MCP's full profile ... so you pick the right tool_id → invoke RUNS that tool.' It contrasts invoke vs install: 'prefer invoke for a single/occasional use' and 'Use install only to make an MCP PERMANENT in the active toolkit.' It also mentions list_tools as the way to see callable tools, and request_mcp for when nothing fits.

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, and the description adds that bank data will no longer be available and that a re-connection URL is returned. This provides useful context beyond the annotation without contradiction.

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

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

The description is two sentences long, front-loads the primary action, and efficiently covers consequence and return value. Every sentence adds value with no redundancy.

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

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

The tool has a single parameter but its meaning is undocumented, creating a gap. The description adequately covers the main action and outcome but fails to clarify the parameter's purpose. Given the complexity, it is minimally adequate but incomplete.

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 a single required parameter 'item' with 0% description coverage. The description does not explain what 'item' represents (e.g., bank identifier, connection ID), leaving the agent without necessary context to use the tool correctly.

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

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

The description clearly states the tool revokes Open Finance consent, deletes connection data, and returns a re-connection URL. The verb 'disconnect' combined with 'bank' makes 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?

No guidance is provided on when to use this tool versus sibling tools like openfinance_list_connections or openfinance_force_sync. The description implies it's for disconnecting a bank but does not specify 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?

Annotations are consistent with the description, which discloses that the tool modifies state (forces sync, waits, polls), explains the wait parameter (fire-and-forget vs wait), and details return fields including status, executionStatus, lastUpdatedAt, synced, needs_action, and timed_out. This adds significant context beyond annotations.

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

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

The description is information-dense and front-loaded with the key action. It could be slightly trimmed, but every sentence provides value. It balances thoroughness with 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 and lack of output schema, the description covers behavior, parameter options, return structure (results, errors, reconnect_url, timed_out), and error handling comprehensively. 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?

With 0% schema description coverage, the description compensates well. It explains 'wait' as a boolean controlling sync mode (fire-and-forget vs wait) and 'items' as an array of selectors (item_id, connector_id, etc.) with omission syncing all. This adds meaning, though default for wait could be clearer.

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 forces a bank to re-sync one or more connections and waits for completion. It clearly distinguishes from sibling tools like openfinance_list_connections or openfinance_get_item_status by specifying the unique sync-and-wait behavior.

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 (stale balances/transactions), what it does NOT require (disconnecting/reconnecting), how to sync all banks (omit 'items'), and how to handle special cases like needs_action and timed_out. It gives clear actionable advice.

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 significant detail beyond annotations: explains real-time vs degraded state, warning structure for CREDIT accounts, and conditions for fallback. 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?

Four concise sentences: purpose, parameter format, error handling, response shape. No wasted words, well-structured.

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

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

Given simple schema (one array param) and no output schema, the description fully covers usage constraints, error modes, and response shape, making it complete for 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 has 0% description coverage; description adds that account_ids must be an array of strings with size 1–50, which is valuable beyond the schema's type definition.

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

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

Clearly states it returns real-time balance per account id, includes the endpoint path, and distinguishes from sibling tools like list_accounts by focusing on balance retrieval for specific IDs.

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

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

Does not explicitly contrast with alternatives, but provides clear context on when it returns degraded data (upstream unavailable, non-Open Finance connector) and how errors are handled, which indirectly guides appropriate usage.

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

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

Annotations already indicate read-only and idempotent. The description adds significant context: batch result format, potential provider_incident block, and caution about unreliable values during incidents. 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?

Extremely concise: 4 sentences cover purpose, usage, batch shape, and a critical warning. Every sentence adds unique value, no redundancy. Front-loaded with core purpose.

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

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

Given one parameter, no output schema, but annotations present, the description covers batch shape and special incident handling. Doesn't describe full account object structure, but that's likely consistent across endpoints. Adequate for an informed agent.

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

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

Schema coverage is 0%, so description must compensate. It mentions account_ids as an array with size constraint, but does not explain what account_ids represent (e.g., identifiers from list_accounts). Adds moderate value 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 account objects with extended creditData per ID, using a specific verb and resource. It distinguishes from sibling tools like list_accounts by emphasizing the detailed nature and the batch shape.

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 instructs to pass account_ids as an array of 1-50, describes the batch result shape, and warns about provider_incident making values unreliable. However, it doesn't explicitly contrast with alternative tools for when to use this versus list_accounts or get_balance.

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 and idempotentHint true. The description adds significant context: batch shape {results, errors}, lack of paid status field, interpretation of payments[], warning about sparse billId in transactions, and that it does NOT return individual transactions. No contradictions.

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

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

The description is thorough but slightly dense; it could be broken into shorter sentences or bullet points for easier scanning. However, every sentence adds value, and the main purpose 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 the tool's complexity (credit card bill nuances), single parameter schema, and no output schema, the description is complete. It covers return fields, limitations, cross-references to sibling tools, and data interpretation caveats.

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 (bill_ids) with 0% description coverage. The description adds meaning by specifying to use the list tool first and that bill_ids must be an array, providing context 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 the tool returns bill-level detail for credit card bills by id, specifies the endpoint, and lists the response fields. It distinguishes itself from siblings by explicitly stating it does NOT return individual transactions and directs to another tool for that purpose.

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

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

The description provides explicit guidance: use openfinance_list_credit_card_bills first to discover ids, pass bill_ids as an array, and explains caveats about payments[] and paid status. It also tells when to use alternatives for itemized transactions.

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

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

Annotations declare readOnlyHint, idempotentHint, and destructiveHint false. Description adds behavioral details: returns specific fields, reconnect_url behavior (reopens widget in UPDATE mode without disconnecting), and bulk support. No contradiction.

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

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

Two sentences, front-loaded with purpose, covering functionality and usage patterns efficiently. 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?

Covers key aspects: return fields, usage modes, reconnect_url behavior, bulk support. Without an output schema, the description provides enough context for an AI agent to understand the tool's inputs and outcomes.

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?

Input schema has 0% description coverage. Description explains the main usage pattern (omit item for all, pass item for single, item_ids for batch). However, it does not differentiate between 'item' and 'item_id' explicitly, leaving some ambiguity.

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

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

The description explicitly states it returns the current status of a bank connection with specific fields like executionStatus, connector metadata, and reconnect_url. It clearly distinguishes single vs bulk operation, and among siblings it is unique as a status query 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?

Provides clear instructions: omit 'item' for all banks, pass 'item' for single, and accepts item_ids for batched execution. Mentions reconnect_url use case. Lacks explicit when-not-to-use or comparison to siblings, but sufficient context is given.

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 value by specifying the batch return shape ('{ results, errors }') and endpoint, disclosing request/response behavior 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?

Description is a single sentence that efficiently packs the purpose, usage hint, and field list. Front-loaded with the core action. Slightly dense but 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?

Without an output schema, the description thoroughly lists all major fields (interestRates, charges, installments, etc.) and batch shape, making the return value completely understandable. Covers all necessary context for a detail-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?

Schema coverage is 0%, so description must compensate. It mentions the parameter loan_ids and gives a count range (1-50), but does not describe the string format or any constraints beyond that. Partial 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 'Returns full loan contract detail by id' and enumerates specific fields (interestRates, charges, etc.), making the tool's purpose unmistakable. It also distinguishes from sibling openfinance_list_loans by indicating this is for deep-diving.

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

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

Explicitly advises 'Use after openfinance_list_loans to deep-dive on a specific contract.' Also provides parameter guidance ('Pass loan_ids as an array (1-50)'). Lacks when-not-to-use but covers primary use case well.

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

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

Annotations already indicate read-only and idempotent. Description adds critical context: account name is legal entity (not brand), CREDIT balance meaning is connector-dependent, provider_incident makes values unreliable, identity_notice requires deduplication. Also explains response structure including bank, connector_id, and item_id.

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 and front-loaded with core purpose. Each sentence adds value, though slightly verbose in the middle with cautionary notes. Could be more concise but still 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?

No output schema, but description thoroughly explains return fields, including bank, connector_id, item_id, and conditional blocks (provider_incident, identity_notice). Also covers CREDIT balance caveat and filter parameters. Highly complete 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?

With 0% schema coverage, description compensates by explaining item and item_ids usage and type filtering. However, item_id parameter is not explicitly described, though implied from response context. Good but misses one parameter.

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

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

The description explicitly states it returns accounts for bank connections with specific fields (BANK/CREDIT, balance, number, etc.) and distinguishes between listing all accounts or targeting a single bank. It clearly differentiates 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?

Provides explicit when-to-use guidance: OMIT item for all accounts, pass item for a single bank, use openfinance_list_credit_card_bills for standardized bill amounts. Also warns about provider_incident and identity_notice scenarios, and mentions bulk support with item_ids.

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

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

Annotations already declare readOnlyHint and idempotentHint; the description adds caching behavior ('cached for the adapter session') and details on the response structure, complementing the annotations without contradiction.

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

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

Information is front-loaded with the main purpose first, followed by the structure of entries and usage hints. Concise with minimal wasted words, though could be slightly more streamlined.

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

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

For a zero-parameter tool with no output schema, the description sufficiently explains the return format and how to use the data (e.g., via the categoryId), making it complete enough for correct selection and invocation.

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

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

No parameters exist in the input schema, so the description has no requirement to explain parameters; baseline of 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?

Clearly states it returns the transaction category taxonomy and explicitly distinguishes from siblings by noting it is a single aggregated response with no batch ids, referencing the specific API endpoint and caching behavior.

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

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

Provides clear context for when to use the data, such as for updating transaction categories using the 'id' field, and advises preferring the Portuguese translation for pt-BR users. Lacks explicit exclusions or alternatives but is adequate given the tool's simplicity.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond annotations: the reconnect_url does not consume a connection slot and does not require disconnecting first. 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 two sentences, front-loading the return fields and then explaining the reconnect_url's behavior. It is informative but could be slightly more concise. 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?

Given no parameters, no output schema, and rich annotations, the description provides complete context: it lists return fields, explains reconnect_url usage, and clarifies behavioral traits. No gaps are apparent.

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

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

The input schema has zero parameters and 100% schema coverage. The description does not need to add parameter information beyond what the schema provides. Baseline 4 for no parameters is appropriate.

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

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

The description clearly states this tool returns saved bank connections, listing specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). This verb+resource combination is specific and distinguishes it from sibling list tools like openfinance_list_accounts.

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 (during re-authentication needs) and clarifies it doesn't consume a slot or require disconnecting. However, it does not explicitly mention when to use alternative tools like openfinance_disconnect_bank or other list tools, missing some comparative guidance.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds significant behavioral context: derivation of 'payment_status', the meaning of 'payments[]' across bills, open bill availability logic, and connector asymmetry. 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, covering many edge cases. While structured with paragraphs and lists, it could be more concise. Important information is present but requires effort to parse. A more streamlined version would improve usability.

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 of the tool (no output schema, many derived fields, multiple edge cases), the description covers return values, derived fields, warnings, and caveats comprehensively. It explains the structure of 'open_bill' and 'future_bills', and provides failure modes and fallback 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 coverage, the description must explain all 5 parameters. It details 'include_open_bill' and implies 'account_id' is required, but 'page', 'page_size', and 'account_ids' are only briefly mentioned ('Bulk support') without format or default behavior. Missing description for pagination 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 that it returns 'CLOSED credit card bills for a CREDIT-type account' with a specific list of fields. It distinguishes from sibling tools like 'openfinance_get_credit_card_bill' (single bill) and 'openfinance_list_transactions' (transactions), making the tool's purpose unambiguous.

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

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

The description provides extensive usage guidance: when to use 'include_open_bill', warns against assuming payment status from 'payments[]', explains connector asymmetry for open bills, and cautions against cross-bank attribution. It also tells when NOT to use it (e.g., for itemized transactions).

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

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

Annotations already indicate readOnly, idempotent, and non-destructive. The description adds significant value by detailing error handling (returning a warning instead of throwing on 403), data integrity checks with 'suspect_zeroed' flags, and the response structure. It does not explain pagination behavior (page, page_size), which is a minor gap.

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

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

The description is well-structured: main purpose first, then details about fields, error handling, data integrity, and bulk support. It is somewhat verbose but each part adds value. Could be slightly trimmed without loss of 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 no output schema, the description does a good job explaining the return format, error behavior, and data integrity warnings. However, it fails to describe the input parameters thoroughly, leaving a significant gap for a tool with 6 parameters. Overall adequate but not 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?

Schema description coverage is 0%, so the description must explain parameters. It only briefly mentions item_ids for bulk execution. The other 5 parameters (item, page, type, item_id, page_size) are not described at all, leaving the agent to infer their meaning from names alone.

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 an investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). It distinguishes itself from sibling tools like openfinance_list_accounts or openfinance_list_investment_transactions through its focus on the portfolio view.

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 investment data from a connection, but does not explicitly state when not to use it or mention alternatives like openfinance_list_investment_transactions for transaction history. The bulk support hint is provided but overall guidance on tool selection is weak.

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, idempotentHint=true, destructiveHint=false. The description adds value by detailing the types of movements returned and the specific data fields (e.g., agreedRate, expenses). 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?

Three sentences: first defines purpose and return fields, second gives usage sequence, third mentions bulk support. No fluff, efficient and 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 no output schema, the description sufficiently describes return fields and references a prerequisite sibling. It lacks details on pagination defaults for page/page_size, which would be helpful for a list tool, but overall it is fairly 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?

Schema description coverage is 0%, so the description must compensate. It explains that investment_id is required and that investment_ids allows bulk execution. However, it does not explain page and page_size parameters. The description adds some meaning but is incomplete.

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/INTEREST/AMORTIZATION/TRANSFER) and data fields. It distinguishes from sibling tools like openfinance_list_investments (which lists investments) and openfinance_list_transactions (general transactions).

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

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

Explicitly says 'Use after openfinance_list_investments to get the investment_id', providing a clear prerequisite. Mentions bulk support via investment_ids. Does not explicitly state when not to use or list alternatives, but gives sufficient context for correct invocation.

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

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

Beyond annotations (readOnlyHint, destructiveHint), the description adds that requests are sequential with rate-limit spacing and returns per-connection results and errors. This adds useful behavioral context.

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

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

Two sentences with no redundancy. First sentence states core purpose, second covers parameter usage and return format. 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?

The description covers the single parameter, behavioral details (sequential, rate-limiting), and return structure. With no output schema, this is sufficient for the tool's complexity.

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

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

With 0% schema description coverage, the description compensates fully by explaining the items parameter as an array of connection selectors with options (item_id uuid, connector_id, or connector_name), which is essential for correct usage.

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

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

The description clearly states the tool lists loan contracts per bank connection, specifies the HTTP endpoint, and distinguishes from siblings like get_loan_detail. The verb 'list' and resource 'loan contracts' are explicit.

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 usage guidance for the items parameter (pass for specific connections, omit for all) and mentions sequential fetching with rate-limit spacing. However, it does not explicitly compare to other tools or 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds extensive behavioral context beyond annotations: auto-pagination vs manual, 5000 ceiling and truncation, search_queries semantics, detail parameter effects, credit pending/posted variability, error handling returning a specific format, and provider_incident block. 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 but well-structured and front-loaded with the main purpose. Each sentence adds value, though some information (e.g., creditCardMetadata.billId cautions) is repeated. It could be slightly more concise without losing clarity, but the structure is logical and focused.

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, rich annotations), the description is exceptionally complete. It covers all key behaviors: pagination, filtering, error handling, credit card specifics, bulk support, and cross-tool guidance. No obvious gaps remain 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 fully compensate. It does so by explaining each parameter in detail: from/to as ISO dates, search_queries as case-insensitive substring OR, pagination modes for page/page_size, three detail levels with examples, account_id/account_ids for targeting. This adds substantial meaning beyond the raw schema.

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

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

The description clearly states it returns transactions for a bank account, specifying BANK or CREDIT type. It adds that for CREDIT accounts, it is the only way to get itemized transactions. However, it does not explicitly distinguish itself from the sibling tool 'openfinance_list_transactions_by_item', which may serve a different purpose. The verb and resource are specific, but lacking direct sibling differentiation prevents a higher score.

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 this tool versus alternatives. It directs users to use 'openfinance_list_credit_card_bills' for standardized open-bill totals, 'openfinance_list_accounts' for statement closing/due dates, and 'openfinance_get_item_status' if transactions are missing. It also explains when not to rely on billId for totals. This level of detail fully meets the criteria.

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 substantial behavioral context beyond the annotations. It discloses that the tool caps at 5000 transactions per account with a truncated flag, mentions the provider_incident block that may cause incomplete data, and explains the behavior of granularity and detail modes. These are not covered by 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 verbose. It front-loads the main purpose and then details options. While clear, it could benefit from structured formatting like bullet points. However, every sentence adds value, and there is no redundant 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?

Despite having 9 parameters and no output schema, the description covers all aspects: parameter meanings, output structure (e.g., total, por_mes, top_despesas), edge cases (truncated, provider_incident), and bulk support. It provides complete guidance for an agent to use the tool effectively.

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

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

With 0% schema description coverage, the description fully explains all parameters. It specifies that 'item' can be a connector_id, connector_name, or item_id; 'from' and 'to' are ISO dates; 'granularity' defaults to 'monthly' returning a summary; 'detail' changes the richness of data; 'type' filters accounts; and 'top_n' is implied. Every parameter's meaning and effect is described.

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

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

The description clearly states the tool's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes itself by explaining it resolves accounts internally, avoiding the need to call openfinance_list_accounts or carry account IDs. This 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 examples of when to use the tool (e.g., for 'análise anual/mensal', 'fluxo de caixa'). It also explains when to use different granularities and detail options. However, it does not explicitly state when not to use it, such as when only single-account transactions are 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 already indicate readOnly, idempotent, non-destructive. The description adds context about what the tool returns (global indicator, degraded components, open incidents, `your_banks_affected`), providing transparency beyond annotations. No contradiction.

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

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

The description is a single paragraph that is informative but could be more concise. However, it is well-structured with clear purpose and usage guidance.

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

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

No output schema, but the description explains the return value in detail (global indicator, degraded components, open incidents, `your_banks_affected`). Provides complete context for a zero-parameter 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 in input schema, so schema coverage is 100% and description does not need to add parameter info. Baseline 4 is appropriate.

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

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

The description clearly states it checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling tool `openfinance_get_item_status` by specifying it is about the provider's health, not the user's own connection.

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: 'whenever data looks incomplete or stale even though a connection shows UPDATED', and explains what it reveals (upstream outages, incidents on specific banks). Differentiates from `openfinance_get_item_status`.

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

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

The description adds significant behavioral context beyond annotations: what fields are returned, the caveat warning for non-Open-Finance connectors, plan handling, and the hint behavior when keywords are omitted. It does not contradict any annotation.

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 moderately long but each sentence adds value, covering input, output, caveats, plan behavior, and usage order. It could be slightly more concise but is well-structured and front-loaded with key information.

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

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

Given no output schema, the description comprehensively explains return fields (connector id, access, audience, linked connections, connect_url, caveats) and edge cases (hint without keywords, plan-based filtering). It 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?

With 0% schema coverage, the description explains both parameters: keywords[] takes an array of strings with an example, and include_accounts when true returns accounts. While not extremely detailed, it provides practical usage context 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 that the tool searches bank connectors by name, specifying the input format (keywords[]) and output details (connector id, access type, audience, linked connections, connect_url). It distinguishes from sibling tools like 'connect' by stating 'Call this BEFORE connecting', making its purpose explicit.

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

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

The description provides clear usage guidance: call before connecting, keywords[] is required (returns hint otherwise), and explains plan-related behavior (PF hides PJ, PJ covers both). It does not explicitly say when not to use, but the 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?

Annotations readOnlyHint=false, destructiveHint=false leave safety profile ambiguous. Description adds critical behavioral details: overrides automatic categorization, teaches Pluggy by creating a Category Rule, and describes batch error handling (per-item errors don't fail whole batch). 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?

Single paragraph packs a lot of information efficiently. Front-loaded with main action. Could benefit from bullet points or structured formatting, but remains clear and concise.

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

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

For a batch update tool with side effects and error handling, the description covers all essential aspects: input requirements, output shape, side effect (Category Rule), error behavior, and references to related tools. No output schema exists, but response shape is described.

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%, requiring the description to fully explain parameters. It describes the items array structure, the required fields (transaction_id, category_id), their origins, and the response shape (updated, results, errors). This adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool corrects transaction categories via PATCH /transactions/:id. It specifies the resource (transactions), action (update category), and distinguishes from sibling tools by referencing transaction_id from openfinance_list_transactions and category_id from 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?

Provides explicit guidance: use to fix miscategorized transactions, explains how to obtain required IDs from sibling tools, and describes side effects (creates Category Rule). Does not explicitly state when not to use, but context is clear and 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 indicate idempotentHint=true and destructiveHint=false, reducing the burden. The description adds value by specifying that conversation data aids reproduction, which is a behavioral hint beyond 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 filler. Every sentence adds value: purpose and a concrete usage instruction. Perfectly concise for the tool's simplicity.

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?

While annotations cover safety and idempotency, the description lacks detail about the required 'message' parameter (what content to provide) and 'context'. For a 3-param tool with no output schema, the description should explain all inputs more fully.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'conversation' parameter (include recent messages for reproduction) but leaves 'message' (required) and 'context' undescribed. Partial coverage, adequate but not thorough.

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 sends feedback. This verb+resource combination is specific and distinct from sibling tools (e.g., openfinance, authenticate), which focus on financial data or system functions.

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

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

The description explicitly says when to use the tool (report bug, missing feature, or feedback) and provides a concrete guideline: include the conversation array with recent messages for reproduction. No alternative tools exist for this purpose among 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 idempotentHint, readOnlyHint, and destructiveHint, so the description adds value by specifying exactly what versions are shown (platform and adapter). No contradictions.

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

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

The description is a single, front-loaded sentence with no wasted words. It clearly communicates the purpose.

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

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

Given the simplicity of the tool (no parameters, no output schema), the description is complete. It could mention the return format, but it's not critical for a version display tool.

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

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

There are no parameters, so the baseline is 4. The description does not need to elaborate on 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 uses a specific verb ('Show') and resource ('current MCP platform and adapter versions'), clearly stating the tool's function. It is distinct from sibling tools, which are mostly related to Open Finance operations.

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

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

The description implies usage (when you need version info), but provides no guidance on when not to use it or alternatives. For a simple tool, this is adequate but lacks explicit differentiation.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds detail on the return contents but does not disclose additional behavioral traits such as authentication requirements or rate limits. Given the annotations, the description provides sufficient but minimal added context.

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

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

Description is a single, well-structured sentence with no redundancy. It front-loads the core purpose and lists specific return contents efficiently.

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 informational tool with no parameters and annotations, the description fully explains what the tool returns. It covers all relevant aspects of toolkit state, making it complete even without an output schema.

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

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

Tool has zero parameters, so parameter semantics are not applicable. Baseline is 4 for zero-param 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?

Description clearly states the tool returns the current toolkit state with specific components: installed MCPs, connection status, accounts, and catalog tool counts. Verb 'Returns' is specific, and the resource is well-defined, distinguishing it from siblings like show_version 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?

Description implies usage for retrieving toolkit status but does not explicitly mention alternatives or exclusions. However, the detailed description provides clear context and differentiates from sibling tools, so it meets the 'clear context, no exclusions' criteria.

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