Atacadão MCP

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

Description adds context beyond annotations: explains that authentication can be permanent or session-based, that token can be provided to set session, or omitted to get a link. Consistent with idempotentHint (calling with same token idempotent), 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?

Description is moderately concise, front-loaded with purpose. Every sentence adds value (purpose, methods, best practice). Could be slightly tighter but overall efficient.

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

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

Covers key scenarios: permanent vs. session, how to obtain token, how to use. Lacks details on return values or error handling, but sufficient for typical authentication flow without 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?

Schema has 0% coverage for the one parameter 'token'. The description compensates fully: explains that token is optional, what it represents (JWT access token), and behaviors for providing it vs. not. Adds essential meaning.

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

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

The description clearly specifies the tool's role: authenticating to MCP.AI for IDE agents. It details two methods (config-based permanent token or session-only via paste) and distinguishes the resource (access token, login) effectively.

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 usage guidance: when to use config vs. paste, step-by-step instructions (log in, copy token, paste), and best practices. Does not explicitly exclude siblings but the guidance is clear and actionable.

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 behavior. The description adds specific details about response content in different states, such as 'authenticated:true' or 'connect_url'. 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?

Two sentences, front-loaded with the core purpose. No wasted words; each sentence provides distinct and useful information.

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

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

For a stateless status check with no parameters and no output schema, the description fully explains the return value behavior, making it self-sufficient.

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

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

There are no parameters, so the description does not need to add parameter semantics. Baseline of 4 is appropriate given 100% schema 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?

The description clearly states the tool returns connection status and URLs, with specific conditions for connected vs missing credentials. It distinguishes itself from sibling tools 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?

The description implicitly guides usage by explaining what the tool returns, but it does not explicitly state when to use it versus alternatives. However, the purpose is clear enough for an agent to infer.

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

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

Beyond the sparse annotations, the description discloses crucial behaviors: invoke runs tools even when not installed, returns connect/checkout links on auth/payment issues, requires workspace owner/admin for writes, and flags installed_in_toolkit vs installed_in_workspace. 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 long but every sentence earns its place. It flows logically from the core flow (search→describe→invoke) to the key invoke-vs-install distinction, then to billing/auth/owner requirements, and finally to the prompt library. No fluff or repetition.

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 (14 actions, 23 params), the description covers the core flows, edge cases (credentials, payment, permissions), and the prompt library thoroughly. It lacks explicit return formats for some actions (e.g., search results, list_tools), but with no output schema, it still provides enough context 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 coverage, the description meaningfully explains the main parameters through the workflow (action, mcp_id, tool_id, arguments, prompt_slug, etc.). However, it does not explicitly define all 23 params (e.g., conversation, report_context, immediate, tier_slug), though many are inferable from action 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 states the tool is 'The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' This gives a specific verb+resource (catalog and run) and clearly distinguishes it from sibling openfinance tools as the central hub for discovering and executing MCPs.

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

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

It explicitly explains when to use invoke vs install ('prefer invoke for a single/occasional use', 'Use install only to make an MCP PERMANENT'), and covers all other actions: list_tools for callable tools, subscribe/cancel for billing, request_mcp for new MCPs, and separate prompt library actions. This is excellent when-to-use 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 mark destructiveHint=true, indicating irreversible action. The description adds behavioral details: revokes consent, deletes data, and returns a reconnection URL. This goes beyond annotations by explaining the post-action state and the ability to reconnect, which helps an agent understand consequences.

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

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

The description consists of two concise sentences that efficiently convey the core action and outcome. No unnecessary words, front-loaded with the key verb 'Revokes'. 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?

For a destructive tool with one parameter and no output schema, the description covers the action and result adequately. However, it lacks parameter documentation, reducing completeness. The return value (add_connection_url) is noted, which is helpful for post-action steps.

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 and no explanation of the 'item' parameter in the description, the agent has no guidance on what to pass. The description does not mention the parameter at all. For a single required string parameter, the description fails to add meaning beyond the schema.

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

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

The description clearly states the tool's function: revokes Open Finance consent for a specific bank, deletes connection data, and makes bank data unavailable. It also notes the return of an add_connection_url for reconnection. This distinguishes it from siblings like openfinance_list_connections or openfinance_force_sync.

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

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

Description provides no explicit guidance on when to use this tool versus alternatives. It does not specify prerequisites, cautionary notes, or scenarios where other tools might be more appropriate (e.g., pausing vs. disconnecting). The only hint is the destructive nature, but no direct comparison with 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?

Describes polling up to 60s, timeout behavior, fire-and-forget mode, and handling of needs_action with reconnect_url. Consistent with annotations (readOnlyHint=false, destructiveHint=false).

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

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

Long but efficient; every sentence adds value. Well-structured: main action, usage, parameters, return value, special cases.

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

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

Covers all important aspects: behavior, parameters, return format, error states, timeout, fire-and-forget. Adequate for a complex tool with no 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?

Schema has 0% coverage, but the description fully explains both parameters: 'items' as an array of selectors with examples, and 'wait' for fire-and-forget mode.

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 forces a bank to re-sync one or more connections and waits for completion. It distinguishes from sibling tools by specifying the use case for stale balances/transactions.

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

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

Provides explicit guidance on when to use ('when a balance or transaction list looks stale'), and what alternatives exist (re-check with openfinance_get_item_status on timeout).

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 and idempotent, but the description adds rich behavioral context: real-time vs degraded balance, warning handling, response shape, and edge cases like CREDIT accounts and institution unavailability. No contradiction with annotations.

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

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

Description is concise with 5-6 sentences, front-loaded with main purpose, and each sentence adds specific behavioral detail without redundancy.

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

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

Despite no output schema, the description fully explains return shape, error handling, and degradation scenarios, making it complete for an agent to understand 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?

Schema coverage is 0%, but the description compensates by explaining the sole parameter account_ids as an array with size limit (1-50) and its role in fetching balances. It adds meaningful constraint 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 it returns real-time balance payload per account ID and specifies the endpoint. It distinguishes from sibling tools by focusing on real-time balance specifically, not list or detail 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?

Provides usage constraints: account_ids as array (1-50). Describes error scenarios and degradation behavior, but does not explicitly compare to alternative sibling tools like openfinance_list_accounts.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description reveals critical behavioral details: the batch response shape, provider_incident block, and warnings about unreliable values during provider incidents.

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 the main purpose first, followed by usage details and a warning. It is concise with no unnecessary words, though slightly longer due to the provider incident note.

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

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

The description covers the primary function, batch shape, and a specific edge case (provider incident). It lacks explicit detail on return value structure, but given no output schema, the description provides adequate context for a single-parameter tool with safety 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?

Although schema coverage is 0%, the description adds the crucial constraint that account_ids must be an array of 1-50 strings, which is not present in the schema. This significantly aids correct parameter 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 'Returns full account objects including extended creditData per id' and specifies the HTTP method and endpoint path. It distinguishes itself from siblings like openfinance_list_accounts by being a batch detail 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?

The description implicitly indicates usage is for fetching detailed account data by IDs, but it does not explicitly compare to other tools or provide when-to-use versus alternatives.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint. Description adds critical context: batch shape { results, errors }, Pluggy missing paid/status, explanation that payments[] reflect previous bill payment, and warning not to assume payment status.

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?

Detailed but every sentence adds value. Front-loaded with core purpose. Slightly verbose but necessary for a complex financial tool.

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

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

No output schema, yet description explains return shape and fields. Covers edge cases (Nubank sparse billId), limitations (Pluggy no paid/status), and authoritative totalAmount. Comprehensive for a complex 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 fully compensates. Explains bill_ids is an array, recommends using list endpoint first to discover IDs. Adds meaning beyond schema.

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

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

Clearly states it returns bill-level detail for credit card bills by id, listing fields like financeCharges and payments[]. Distinguishes from openfinance_list_transactions for itemized 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 tells when to use (bill detail) and when not to (avoid reconstructing total from transactions). Provides alternatives: openfinance_list_transactions for items and openfinance_list_credit_card_bills to discover IDs. Also advises on date range matching billing cycle.

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 valuable behavioral context: the reconnect_url reopens the widget in UPDATE mode without disconnecting or consuming a slot, and explains return format for both single and bulk queries. 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 three sentences, each carrying essential information: what is returned, how to use for single/all, and bulk support. No redundant text, front-loaded with key details.

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

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

Given no output schema and three optional parameters, the description covers return values for single and all modes, bulk support, and behavioral traits. It doesn't explain error handling or parameter relationships (e.g., item vs item_id), but is largely complete for a read-only tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'item' and 'item_ids' but does not mention 'item_id', leaving its purpose ambiguous. While it adds meaning for two parameters, the third is underexplained.

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

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

The description clearly states the tool returns the current status of a bank connection, including specific fields like executionStatus and reconnect_url. It distinguishes single vs. all banks and mentions bulk support, making the purpose very specific compared to 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 explains when to use the tool (get status) and provides usage instructions for different cases: omit item for all, pass item for single, and bulk via item_ids. It does not explicitly mention when not to use or alternatives, but the context is clear.

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

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

The description adds context beyond annotations (which already declare readOnly, idempotent, non-destructive) by mentioning the HTTP method, path, and batch response shape with results and errors. It does not contradict 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 that lists many fields but remains efficient. It could be slightly more structured, but it avoids unnecessary words.

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

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

Given no output schema, the description compensates by listing key response fields and indicating the batch shape. It is sufficient for an agent to understand the tool's output, though some details like error statuses are omitted.

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 the schema has 0% description coverage, the description explains that loan_ids should be passed as an array of strings with a limit of 1-50. This adds practical guidance beyond the schema 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?

The description clearly states it returns full loan contract detail by ID, listing specific fields like interestRates, amortizationScheduled, etc. It distinguishes itself from openfinance_list_loans, which is a sibling tool for listing loans.

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 to use after openfinance_list_loans for deep-diving into a specific contract. It also specifies the array size limit of 1-50 and the batch shape. However, it does not mention alternative tools for other scenarios.

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/destructive hints. Description adds critical caveats: connector-dependent credit balance, provider_incident unreliable data, identity_notice dedup rules. 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?

Description is long but every part is relevant. Front-loads main purpose. Could benefit from bullet points for caveats, but overall efficient for the complexity.

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

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

Covers all key aspects: response fields, bulk support, credit card bill specifics, provider incidents, identity deduplication. No output schema, but description sufficiently details return values.

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

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

Schema has 0% coverage; description covers 'item' and 'item_ids' in context but does not explicitly explain 'type' (filter enum) or singular 'item_id'. Parameters are implied but not fully documented.

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

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

The description clearly states it returns accounts (BANK and CREDIT) with specific fields. It distinguishes from siblings like openfinance_list_credit_card_bills by noting where to get standardized bill amounts.

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

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

Explicit guidance on when to omit 'item' for all-accounts vs. pass 'item' for a single bank. Also provides alternatives for credit card bill data and warns about balance interpretation.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds caching behavior, single aggregated response, and details about response fields, adding value beyond annotations.

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

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

Two sentences, each informative and front-loaded. No wasted words.

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

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

Given no parameters and annotations present, description covers caching, response structure, and relevance to another tool. Minor gaps like prerequisites, but adequate.

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

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

No parameters, schema coverage 100%. Baseline 4 applies.

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

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

Description states it returns Pluggy's transaction category taxonomy, cached for the adapter session, and distinguishes from sibling tools by specifying it's a list of categories used by another 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?

Description implies usage for getting categories but does not explicitly state when to use vs alternatives or any exclusions. However, the tool is simple and context is clear.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by detailing the reconnect_url behavior (opens widget in UPDATE mode, does not consume slot) and explaining the output fields. 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 informative but slightly verbose. It is front-loaded with the main purpose and includes necessary details. Could be slightly more concise, but overall 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?

For a tool with zero parameters and no output schema, the description provides complete context: it lists the output fields, explains the reconnect_url and add_connection_url usage, and covers behavioral details. Nothing essential is missing.

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 0 parameters, so no additional meaning is needed. Baseline score of 4 is appropriate as the description does not need to compensate for parameter documentation.

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

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

The description clearly states the tool returns saved bank connections and lists specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes itself from sibling tools by focusing on listing connections and explaining the unique reconnect_url and add_connection_url.

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 scenarios) and clarifies that it does not consume a connection slot or require disconnecting. It lacks explicit guidance on when not to use this tool versus alternatives like connect or authenticate, but the context of listing is clear.

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

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

Annotations confirm read-only, idempotent, non-destructive. Description adds critical context: payment status derivation logic, bill grouping reliability, connector asymmetry for open bill, and warning 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?

Description is lengthy but front-loaded with the core purpose and structured logically. Each section addresses a specific concern (payment status, open bill derivation, connector asymmetry). Could be slightly more concise, but no redundant sentences.

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 thoroughly explains return structure, derived fields (`payment_status`, `open_bill`, `future_bills`), edge cases (connector asymmetry, grouping warnings), and essential usage guidance. Covers all five parameters adequately.

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

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

Schema has 0% description coverage, but description compensates by explaining `include_open_bill` (opt-in logic) and `account_ids` (bulk support). Pagination params (`page`, `page_size`) are not explicitly described but are standard. The description adds significant meaning beyond schema.

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

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

Description clearly states it returns closed credit card bills for CREDIT-type accounts, listing specific fields and derived attributes. It distinguishes from siblings like openfinance_list_transactions (which gets individual transactions) and openfinance_get_credit_card_bill (single bill).

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 this tool (e.g., to get closed bills with payment status) and when not to (e.g., use openfinance_list_transactions for itemized purchases). Provides alternatives and warns about connector asymmetry for open bills.

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 well beyond annotations (readOnlyHint, idempotentHint, etc.). It details handling of errors, data integrity checks for mass zeroing, and flagging of suspect rows. No contradictions with annotations.

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

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

The description is informative but somewhat lengthy. It is well-structured with overview, field details, error handling, and data integrity warnings. Every sentence adds value, though minor trimming could improve conciseness.

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

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

Given the complexity (multiple asset types, error modes, data integrity logic) and lack of output schema, the description covers key behaviors. However, it lacks details on pagination (page/page_size), sorting, and batch processing with item_ids.

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

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

With 0% schema description coverage, the description should compensate but only briefly mentions item_ids for batched execution. The other five parameters (item, page, type, item_id, page_size) are not explained, leaving their semantics unclear.

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 an investment portfolio for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.). This differentiates it from sibling tools like openfinance_list_accounts or openfinance_list_transactions.

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

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

The description implies usage for retrieving investment portfolios but does not explicitly state when to use this tool versus alternatives like openfinance_list_investment_transactions. It mentions error handling (returns empty for non-enabled investments) but lacks direct guidance on selection.

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

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

The description adds value beyond annotations by detailing the specific fields returned (quantity, value, netAmount, etc.) and the bulk feature. It aligns with annotations (readOnlyHint, idempotentHint, destructiveHint). It could mention pagination behavior but the schema already includes page and page_size, mitigating the 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 very concise: two short sentences plus one for bulk support. It front-loads the purpose and includes necessary details without redundancy or 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 tool has 4 parameters and no output schema, the description covers the main aspects: purpose, prerequisite, bulk support, and field details. It lacks explanation of pagination parameters but they are inferable from the schema. It is fairly complete for an agent to use the tool correctly.

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

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

Schema coverage is 0%, so the description must explain parameters. It explains the key parameters investment_id and investment_ids (bulk), but does not describe page and page_size, which are self-explanatory but still missing from the description. The explanation of core parameters is sufficient but not complete.

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 movement history for investment positions with specific transaction types (BUY, SELL, etc.) and details the fields returned. It distinguishes itself from sibling tools like openfinance_list_investments and openfinance_list_transactions by specifying the resource and prerequisite usage.

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 to use after openfinance_list_investments to obtain the investment_id, providing a clear prerequisite and sequence. It also mentions bulk support for batched execution. However, it does not explicitly state when not to use it or alternative tools for general 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?

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds crucial behavioral details: sequential querying per connection, rate-limit spacing, and the return format `{ results, errors }` per connection. No contradiction with annotations.

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

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

Three sentences effectively front-load the purpose, then explain parameter usage and alternative behavior. No wasted words, and every sentence provides essential 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 still covers return format, handling of multiple connections, and optional parameter behavior. It is fully adequate for a simple list tool with one parameter.

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 coverage is 0%, the description thoroughly explains the `items` parameter: its value types (item_id uuid, connector_id, or connector_name) and the effect of omitting it (list across all linked banks). This adds significant meaning beyond the bare schema type 'array of strings'.

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 specifies the exact resource ('loan contracts per bank connection') and HTTP method ('GET /loans'), distinguishing it from sibling 'openfinance_get_loan_detail' which provides detail on a single loan.

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

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

The description clearly explains how to use the `items` parameter to target specific connections or omit it for all banks, and notes sequential querying with rate-limit spacing. It does not explicitly mention when not to use this tool, but the context is clear enough.

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

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

Annotations already provide readOnlyHint and idempotentHint. The description adds critical context: on upstream errors, it returns a structured response instead of throwing; pagination behavior (auto-paginates up to 5000); detail levels and their implications (tokens per row, coverage varies); the account echo block; provider_incident block; and per-connector inconsistencies. 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, but every sentence adds value. It is front-loaded with the core purpose and then details. However, it could benefit from clearer sectioning or bullet points to improve scanability. Given the amount of necessary detail, the length is justified, but a bit more structure would enhance conciseness.

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

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

The description covers all aspects: return format (account echo, transaction list, total, truncated, warning, error), pagination, detail levels, error handling, bulk support, cross-references to siblings (openfinance_list_accounts for closing dates, openfinance_get_item_status for health, openfinance_force_sync for sync issues), and provider incidents. No output schema exists, so it compensates 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 fully explain parameters. It does: from/to as ISO YYYY-MM-DD, search_queries as case-insensitive substring match with OR semantics, detail levels (compact, rich, raw) with specific fields returned for each, page and page_size behavior (auto vs manual, defaults, maximums), account_id vs account_ids for bulk. It even explains the ceiling of 5000 and truncation.

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

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

The description clearly states the tool returns transactions for a bank account (BANK or CREDIT type). It distinguishes itself from siblings like openfinance_list_credit_card_bills by specifying that for CREDIT accounts, this is the ONLY way to get itemized transactions. The verb 'returns' is specific and the resource is 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 provides extensive guidance: when to use this tool vs openfinance_list_credit_card_bills for credit card bills, how to paginate (auto vs manual), when to narrow from/to if truncated, how to handle zero results for CREDIT accounts (check item status), and the importance of cross-checking the account echo. It also warns against summing by billId and explains the consistency of billId hints. This is exemplary.

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 important behavioral details beyond these annotations: the scan caps at 5000 transactions per account with a 'truncated:true' flag, and the presence of a 'provider_incident' block that indicates potential incomplete data. It also clarifies that reconnecting does not fix provider issues. 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 well-structured, starting with the core purpose then expanding into parameter details and behaviors. Every sentence adds value for the agent, especially given the tool's complexity (9 parameters, multiple granularities). It could be slightly more concise, but it is not overly verbose.

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 (9 parameters, no output schema, and annotations providing safety hints), the description is remarkably complete. It covers purpose, all parameter details, behavioral nuances (truncation, provider incidents), and provides concrete usage guidance. There are no missing pieces that would leave an agent confused.

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 9 parameters with 0% schema description coverage, so the description must compensate. It explains the meaning of most parameters: item (targets one bank or all), from/to (ISO dates), granularity (monthly vs raw), detail (compact, rich, raw), type (BANK or CREDIT), and item_ids (bulk support). However, the 'top_n' parameter is not explicitly described, though it is implied by 'largest N each.' This is 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 the tool's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes itself from sibling tools like openfinance_list_accounts and openfinance_list_transactions by emphasizing that it resolves accounts internally and fans out transactions, so users don't need to call those tools first.

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

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

The description explicitly tells when to use this tool versus alternatives: 'so you do NOT need to call openfinance_list_accounts first nor carry account_id uuids between calls.' It also provides when to omit the item parameter for all banks, lists concrete use cases like 'análise anual/mensal', specifies when to use granularity 'raw' vs 'monthly', and warns about data caps and provider incidents.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive. The description adds behavioral detail: returns global indicator, degraded components, open incidents, and flags affected banks. 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?

Single paragraph with front-loaded first sentence stating core purpose. Every sentence adds value, though could be slightly more concise. Overall 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 no output schema and zero parameters, the description is fully complete: explains return values, usage context, and how it integrates with connected banks.

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; baseline 4. The description adds meaning by explaining what the tool does, which is sufficient for a parameter-less 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?

Clearly defines the tool as checking the LIVE operational status of the Open Finance provider, distinct from the connection-level tool 'openfinance_get_item_status'. Uses specific verb+resource and differentiates itself among siblings.

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 the tool (when data appears incomplete/stale despite updated connection) and what it reveals (upstream outage or incident). Lacks explicit when-not-to-use, but context is sufficiently clear.

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

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

Annotations declare readOnlyHint, idempotentHint, and non-destructive. The description adds significant behavioral context: caveat for non-Open-Finance connectors, plan-based visibility of banks, and the fact that the tool never dumps the entire catalog. 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 dense with information but well-structured and front-loaded. It includes example, caveat, plan behavior, and usage guidance. Every sentence adds value, though slightly verbose; still 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?

Despite no output schema, the description details the return structure (connector id, access type, audience, linked connections, accounts, connect_url) and special behaviors (caveat warning, plan honors). It is fully complete 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?

Schema description coverage is 0%, so the description must compensate. It fully explains both parameters: keywords[] is required and returns a hint if omitted, with example usage; include_accounts triggers account details in the response. This adds complete semantic meaning.

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

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

The description clearly states the tool's purpose: searches bank connectors by name and returns connector details, a connect URL, and linked connections. It gives specific verb and resource, includes example keywords, and distinguishes from siblings by instructing to call this before connecting.

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

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

The description explicitly states when to use this tool: 'Call this BEFORE connecting to hand the user a one-click link to the right bank.' It also explains the behavior of the required keywords parameter and the include_accounts option. However, it does not explicitly exclude alternative tools or provide when-not-to-use scenarios, but the context is clear.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false), the description discloses that it overrides automatic categorization, teaches the system by creating a Category Rule (case-insensitive exact match) for future similar transactions, and details the batch response shape including per-item errors. This adds critical behavioral context.

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

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

The description is concise yet comprehensive, efficiently using each sentence to convey purpose, parameter structure, behavioral side effects, and response format. It is well-structured and front-loaded with the main purpose.

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

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

Given the tool's complexity (batch update with side effects and no output schema), the description covers all necessary aspects: purpose, parameter format, behavioral implications, and response structure. There are no critical gaps.

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

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

With 0% schema description coverage, the description fully compensates by explaining the items array structure, the meaning of each field (transaction_id, category_id), and where to obtain them from other tools. This provides complete parameter semantics beyond the schema.

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

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

The description clearly states the verb 'corrects' and resource 'category of transactions', specifies the API endpoint (PATCH /transactions/:id), and distinguishes from sibling tools by referencing specific related tools (openfinance_list_transactions, openfinance_list_categories) and the batch nature.

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 for use (fix miscategorized transactions and improve accuracy), tells where to get required IDs from sibling tools, and warns about the side effect of creating a Category Rule. However, it does not explicitly state when not to use the tool or mention alternatives beyond sourcing 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 non-destructive and idempotent behavior. Description adds that conversation array is needed for reproduction, which is useful but does not contradict annotations.

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

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

Two sentences, front-loaded with purpose, efficient without extra 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?

Simple tool with 3 params and no output schema. Description covers main purpose and one usage instruction, but lacks details on report handling or expected outcome.

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%. Description only explains the 'conversation' parameter, leaving 'message' and 'context' undefined beyond schema names. Does not fully compensate 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 the tool reports bugs, missing features, or feedback, using specific verbs and resources. It distinguishes itself from sibling financial 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?

Implied usage for reporting issues, but no explicit guidance on when not to use or alternatives. The instruction to include conversation array is helpful but doesn't cover avoidance scenarios.

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

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

The description adds context beyond annotations by specifying the exact information returned (MCP platform and adapter versions). 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?

Single, well-formed sentence that is perfectly concise and front-loaded, accomplishing the goal without any wasted words.

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

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

Given zero parameters and no output schema, the description adequately explains the tool's behavior. It lacks detail on the exact format of versions, but this is acceptable for a straightforward 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?

No parameters exist, so baseline score of 4 applies. The description correctly indicates no input 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 clearly states the tool shows current MCP platform and adapter versions, distinguishing it from all sibling tools which perform authentication, data retrieval, or financial 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 is clear about what the tool does and implies it should be used when version information is needed. No exclusion or alternative guidance is necessary 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the tool's safety profile is covered. The description adds meaningful context by specifying the exact content of the returned state (installed MCPs, connection status, accounts, catalog tool counts), which goes beyond the annotations and helps the agent understand what to expect.

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 key verb 'Returns' and immediately specifies the resource. Every word adds value, and there is no redundancy or extraneous information.

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

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

For a simple, parameterless info tool, the description is complete. It fully explains what the tool returns, covering the key aspects an agent would need to know. No output schema exists, but the description enumerates the return content sufficiently. No additional context is necessary.

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 does not need to explain parameter semantics. The schema coverage is trivially 100% with an empty properties object. A baseline score of 4 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 the tool's function with a specific verb ('Returns') and resource ('current toolkit state'), listing the exact components returned (installed MCPs, connection status, accounts, catalog tool counts). It does not explicitly distinguish this from siblings like show_version, but the purpose is 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 alternatives such as show_version, report_bug, or the openfinance_* tools. The description only states what the tool does, without any mention of scenarios, prerequisites, or exclusions.

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