Carrefour MCP

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

The description adds significant behavioral context beyond annotations: calling without args returns a login link, calling with a 'token' arg accepts a JWT for session login, and mentions a permanent method via config. 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, efficiently conveying options. The first sentence is slightly long but still clear. 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 an authentication tool with no output schema, the description fully covers the two behaviors (with/without token) and mentions a permanent alternative. No missing information for its purpose.

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

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

The single optional parameter 'token' is fully explained: it is a JWT that the user pastes. Since schema coverage is 0%, the description compensates entirely, adding meaning and usage 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 is for authentication, specifying it provides a login link or accepts a token. It distinguishes itself from sibling tools like 'connect' or 'openfinance_*' 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 explains when to use the tool: for IDE agents to log in, with two options (permanent config vs. session-only token). It does not explicitly state when not to use it, but the context is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context by detailing the different return values based on connection state, which is beyond what annotations provide.

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

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

The description is two sentences, front-loaded with the primary purpose, and every clause adds value. It is efficient and avoids redundancy.

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

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

Given zero parameters, read-only annotations, and no output schema, the description completely explains the tool's behavior. It covers the two possible outcomes, making it sufficient for an AI agent to understand the tool.

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

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

There are no parameters, so the description does not need to add parameter information. Schema coverage is 100% as there are no parameters to document.

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, specifying two distinct states (all providers connected vs. missing credentials). This verb+resource purpose distinguishes it from siblings like authenticate and openfinance_list_connections.

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

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

The description implies usage for checking connection status before further actions, but does not explicitly state when not to use or provide alternatives. However, given the context of sibling tools like authenticate, the usage 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 show readOnlyHint: false, openWorldHint: true, destructiveHint: false. Description adds significant behavioral context: writes require owner/admin, invoke works without installation, may return connect/checkout links. This goes beyond annotations.

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

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

Description is lengthy but information-dense and well-structured in a logical flow. It front-loads the purpose. Could be more concise with bullet points, but justified given the tool's complexity.

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

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

Covers main workflow and key actions, explains auth/payment handling, installation implications. However, lacks detail on exact output structures for all actions and error handling. No output schema. Adequate for primary use cases.

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 15 params with 0% description coverage. Description explains the overall workflow and mentions some params (action, query, mcp_id, tool_id, arguments) but does not provide detailed semantics for each, especially less common ones like tier_slug, request_name. Partial compensation but not comprehensive.

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

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

The description clearly states the tool is the official mcp.ai marketplace for discovering and running MCPs. It enumerates actions (search, describe, install, etc.) and distinguishes it from external registries. It is specific and differentiates from sibling tools (mostly openfinance 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?

Explicitly tells the agent to use this tool first when the user wants a capability, before any external registry. Explains the core flow and when to use invoke vs install, and mentions auth/payment scenarios. Provides clear context for 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 provide destructiveHint=true and readOnlyHint=false. The description adds behavioral context: data deletion, unavailability of data, and return of add_connection_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 key action, no unnecessary words. Efficiently conveys purpose and side effects.

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 with no schema description and no output schema, the description compensates partially by mentioning the return value (add_connection_url). However, it fails to define the parameter, which is a critical gap for a destructive tool.

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

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

The input schema has one required string parameter 'item' with 0% schema description coverage. The tool description does not explain what 'item' represents (e.g., bank ID, connection ID), leaving the agent unable to determine the correct value.

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

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

The description clearly states the tool revokes consent and deletes connection data, with a specific verb 'revokes' and resource 'Open Finance consent for a specific bank'. It distinguishes from siblings like openfinance_list_connections (lists) and openfinance_force_sync (syncs).

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 use for disconnecting a bank, but lacks explicit guidance on when to use versus alternatives like openfinance_list_connections or openfinance_get_item_status. No prerequisites or exclusions are mentioned.

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

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

Discloses key behaviors: waits up to ~60s, polls until finish, uses PATCH then polling, and returns specific fields (status, executionStatus, etc.). Annotations are not contradicted; the description adds timing and polling details beyond the annotations.

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

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

The description is comprehensive yet reasonably concise. It front-loads the main action and then provides details. A few minor redundancies could be trimmed, 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?

With no output schema, the description fully explains the return structure (results, errors, status, executionStatus, etc.) and error conditions (needs_action, timed_out). All necessary context for using the tool is provided.

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 fully compensates by explaining both parameters: items as array of selectors with omission meaning all, and wait as fire-and-forget when false. No additional info 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 forces a re-sync and waits for completion, specifying the verb 'force sync' and resource 'bank connections'. It distinguishes from siblings by mentioning that stale data can be refreshed without disconnecting, and references openfinance_get_item_status for re-checking.

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 ('when a balance or transaction list looks stale') and what it does not do ('WITHOUT disconnecting/reconnecting'). It also discusses the wait parameter for fire-and-forget behavior. However, it doesn't list explicit alternatives for other scenarios, though it does mention a sibling for re-checking.

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, including degradation to last-synced balance, warning handling for CREDIT accounts, and response shape. 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 concise, well-structured, and front-loaded with the purpose. Every sentence adds value without unnecessary fluff.

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

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

Given the simple parameter set and annotations, the description covers the essential behavior, error handling, and response format. It is sufficiently complete for an agent to use correctly.

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

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

The schema has 0% description coverage, but the description adds the constraint that account_ids must be an array of 1-50 strings. This provides meaningful guidance not present in the schema.

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

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

The description clearly states the tool returns real-time balance per account id, specifying the endpoint and the parameter format. It is specific about the resource and action but does not explicitly differentiate from sibling 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 lacks explicit guidance on when to use this tool versus alternatives. It does not mention when to prefer this over other balance-related endpoints or provide any usage 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 provide readOnlyHint and idempotentHint. The description adds behavioral context: the provider_incident block, unreliable limits, the batch shape of results/errors, and the constraint of 1-50 items. This goes beyond the annotations.

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

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

The description is very concise: two sentences plus a caution. It is front-loaded with the main action, followed by parameter details and a warning. No extraneous text.

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

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

Given no output schema, the description covers the purpose, parameter constraint, batch shape, and a data quality warning. It does not detail the full fields of account objects, but it mentions 'full account objects including extended creditData' which is sufficient for the context of a read-only idempotent 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?

The schema has 0% description coverage. The description adds that account_ids is an array of strings with a length constraint of 1–50, which is not in the schema. It also indicates the batch behavior, adding 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 states it returns 'full account objects including extended creditData' and identifies the endpoint as GET /accounts/:id. It clearly distinguishes from siblings like openfinance_list_accounts, which likely returns a summary list.

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 describes what the tool does and includes a caution about provider incidents, but does not explicitly state when to use this tool versus siblings like openfinance_list_accounts or openfinance_get_account_balance. The usage context is implied but not directly compared.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context: the batch `{ results, errors }` shape, the fact that Pluggy does not return a paid/status field, and the nuanced payment timing in Brazilian Open Finance. It also explicitly warns against reconstructing bill totals from transactions. This enriches the agent's understanding beyond annotations.

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

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

The description is fairly long but highly informative. Each sentence contributes necessary context or usage guidance. It is front-loaded with the core purpose, then adds disclaimers and alternatives. Could be slightly trimmed, but structure is logical and efficient.

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

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

Given the complexity (credit card billing details, batch handling, connector-specific nuances), the description covers: what is returned, what is not returned, how to get transactions, how to discover bill IDs, batch shape, and important caveats about Pluggy and Brazilian Open Finance. No output schema exists, but the description explains the response sufficiently.

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

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

Despite zero schema description coverage, the description adds essential meaning: it specifies that `bill_ids` must be an array and directs users to first discover ids via openfinance_list_credit_card_bills. It also mentions the batch response shape. This compensates well for the simple parameter type.

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

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

The description explicitly states the tool returns bill-level detail for credit card bills by id, names the endpoint (GET /bills/:id), lists specific fields (financeCharges, payments), and clearly distinguishes from transaction-level data. It also describes the batch response shape, leaving no ambiguity about what the tool does.

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 (to get bill detail), when not to use it (do not reconstruct totals from transactions), and directs to alternatives (openfinance_list_transactions for itemized transactions, openfinance_list_credit_card_bills to discover ids and for payment status). It also warns about the sparse billId hint and the interpretation of payments in Brazilian Open Finance.

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, so the description does not need to add safety details. It does add output specifics (executionStatus, connector metadata), which provides some behavioral context but no new traits beyond what annotations imply.

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 main purpose, followed by precise usage instructions. 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?

For a tool with one optional parameter and no output schema, the description covers all necessary information: what it returns, how to use both modes, and the structure of the response for the multi-bank case.

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

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

The input schema has 0% description coverage, so the description fully compensates by explaining that the optional `item` parameter, when omitted, returns all banks with a count, and when provided, returns a single bank's status. This adds complete 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 returns the current status of a bank connection, listing specific status values and metadata. It distinguishes between retrieving all connections or a single one, differentiating it from sibling tools like openfinance_list_connections.

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

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

The description explicitly explains when to omit or include the `item` parameter, guiding the agent on both modes of use. It does not explicitly mention when not to use this tool, but the context is clear enough for effective selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds useful context about batch shape and array size constraints, without contradicting annotations.

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

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

The description is informative but not overly verbose. It is structured: first details what is returned, then usage guidance, then parameter info. Could be slightly more concise, 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?

Given no output schema and one parameter, the description covers the key return fields and parameter usage. It lacks some specifics but provides a solid overview for selecting and invoking the tool.

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

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

With 0% schema description coverage, the description adds meaning: 'Pass loan_ids as an array (1-50)' and mentions batch result shape. This compensates for the schema gap.

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

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

The description clearly states it returns full loan contract detail by ID, specifies the endpoint, and lists many fields. It distinguishes from siblings by advising usage after openfinance_list_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?

Explicitly says 'Use after openfinance_list_loans to deep-dive on a specific contract', providing clear context. Also mentions batch behavior and array size limits.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. Description adds critical behavioral context: CREDIT balance meaning is connector-dependent, the presence of a provider_incident block may make balances unreliable, and explains that 'name' is legal entity while 'bank' is brand. No contradiction with annotations; enhances agent understanding 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 detailed but front-loaded with the core purpose. The structure uses paragraphs for different aspects (output fields, usage, CREDIT balance nuance, provider incident). Could be slightly more concise, but the detail is justified given the complexity. No filler 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, the description fully explains return values: fields like balance, number, type, subtype, bankData, creditData, bank, connector_id, item_id. It also explains edge cases (provider incident, CREDIT balance meaning) and provides fallback for standardized bills. Complete for an agent to understand and 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?

Description explains both parameters: 'type' as enum BANK/CREDIT, and 'item' to target a single bank. It explains the output fields related to parameters (e.g., 'bank', 'connector_id', 'item_id'). Schema coverage was 0%, so description compensates well, though additional format details (e.g., expected string format for item) could be beneficial. Sufficient for correct invocation.

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

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

The description clearly states it returns accounts for a bank connection, differentiating between BANK and CREDIT types, and lists the fields returned (balance, number, etc.). It distinguishes itself from sibling tools like openfinance_list_credit_card_bills by noting that for standardized bill amounts, the sibling should be used. The verb 'list' and resource 'accounts' are specific and unambiguous.

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

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

Provides explicit when-to-use guidance: Omit 'item' for all accounts, pass 'item' for a single bank. Warns about the meaning of CREDIT balance being connector-dependent and not to treat as 'this month's bill'. Recommends using openfinance_list_credit_card_bills for standardized open-bill amount. Also advises on not presenting values when provider incident is present. Clear usage context and 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?

The description adds valuable behavioral context beyond annotations: it discloses caching (cached for the adapter session), states the response is a single aggregated list, and explains the structure including parent-child relationships. This supplements the readOnlyHint and idempotentHint annotations well.

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

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

The description is concise and well-structured: it leads with the primary purpose, then details the fields, caching behavior, and usage hint. Every sentence is informative with no wasteful 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 having no output schema, the description fully explains the return structure (id, description, descriptionTranslated, parentId, parentDescription) and mentions caching and singleton response. With no parameters, this is 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?

The tool has no parameters, so according to the rubric, baseline is 4. The description does not need to add parameter semantics beyond the schema, which already covers all parameters (none).

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 Pluggy's transaction category taxonomy, cached for the session, and mentions the source endpoint (GET /categories). It also distinguishes from siblings by noting that the categoryId is used by openfinance_update_transaction_category.

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

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

The description explains the output fields and caching behavior, which helps the agent understand when to use this tool (e.g., to retrieve category hierarchy). However, it does not explicitly state when not to use it or provide alternatives 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 provide readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying that it returns an add_connection_url for linking additional banks, which is behavioral context not captured by 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 sentence that efficiently conveys the purpose and key details. It is front-loaded with the main action, though could be slightly more structured with bullet points for readability.

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

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

For a parameterless tool with annotations and no output schema, the description adequately explains the return fields and includes a notable detail (add_connection_url). However, it does not mention potential limits like pagination or max connections, which would enhance completeness.

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

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

Input schema has 0 parameters, so schema description coverage is 100%. The description does not need to explain parameters, and baseline is set to 4 per guidelines.

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, add_connection_url). It distinguishes from sibling tools like 'authenticate' and 'connect' by focusing on listing existing connections.

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

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

The description implies usage for retrieving saved connections without providing explicit guidance on when to use this tool versus alternatives like 'authenticate' or 'connect'. No when-not-to-use or prerequisites are mentioned.

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?

Exhaustively describes behavior beyond annotations, including payment status derivation, connector asymmetry, open bill logic, and reliability warnings. No contradiction with annotations (readOnly, idempotent, non-destructive).

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

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

The description is very long and dense, containing extensive details. It starts with a clear statement but includes many asides and warnings. While structured with sections, it could be more concise.

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

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

Given the tool's complexity, no output schema, and zero schema descriptions, the description covers many aspects: return fields, payment logic, open bill derivation, connector issues, and warnings. It is comprehensive, though somewhat verbose.

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

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

Schema description coverage is 0%, so description must compensate. Includes detailed explanation for 'include_open_bill' and mentions 'account_ids' for batching, but does not describe 'page' and 'page_size' parameters, leaving some 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?

Clearly states 'Returns CLOSED credit card bills for a CREDIT-type account' with specific fields listed. Distinguishes itself by focusing on closed bills, but could contrast with the sibling 'openfinance_get_credit_card_bill'. Still, 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?

Provides some guidance: mentions when to use 'include_open_bill' and contrasts with 'openfinance_list_transactions' for itemized purchases. However, does not explicitly differentiate from the sibling 'openfinance_get_credit_card_bill' or specify when to use this tool versus alternatives for bill retrieval.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. Description adds error handling behavior (returns structured error object) and lists available data fields. This adds value beyond annotations.

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

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

The description is a single paragraph with all necessary information front-loaded. It's concise but could be slightly better structured (e.g., separated sections). Still efficient.

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

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

Covers purpose, error handling, and data fields, but lacks parameter explanations. For a 4-param tool with no output schema, more detail on inputs would be expected.

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 4 parameters with 0% coverage; description does not explain any of them (item, page, type, page_size). Despite listing fields in results, there is no added meaning for input parameters.

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

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

The description clearly states it returns investment portfolio data for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.), which is a specific verb+resource. It distinguishes itself from siblings like openfinance_list_investment_transactions by focusing on holdings.

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

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

Describes when to use (for connections with INVESTMENTS enabled). Implicitly indicates not for other types of data. Lacks explicit alternatives or when-not-to-use, but context is clear.

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

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

Annotations already indicate readOnlyHint, idempotentHint, destructiveHint. Description adds details on supported transaction types and fields, and mentions bulk execution. Does not explain pagination behavior (page, page_size parameters are undocumented), but overall adds value beyond annotations.

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

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

Two concise paragraphs with clear purpose and additional hints. Could be slightly more structured (e.g., list parameters), but no unnecessary 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?

Describes output fields and provides usage context, but lacks pagination behavior and does not fully describe output format (no output schema). Missing explanations for page and page_size parameters.

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

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

The description explains investment_id and investment_ids (bulk) but does not mention page or page_size parameters. With 0% schema description coverage, the description should cover all parameters; it covers 2 of 4.

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

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

The description clearly states it returns movement history for investment positions, listing specific transaction types (BUY, SELL, TAX, etc.) and fields. It distinguishes from sibling tools like openfinance_list_investments and openfinance_list_transactions by focusing on investment-specific 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 a clear usage sequence ('Use after openfinance_list_investments') and mentions bulk support. Does not explicitly mention alternatives or when not to use, but the sibling list implies 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?

Discloses sequential querying with rate-limit spacing and the return format per connection. Annotations already indicate read-only, idempotent, non-destructive, so description adds valuable behavioral 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?

Description is concise with three sentences, front-loads purpose and endpoint, and includes all necessary details 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?

Covers parameter usage, behavior, and return structure. However, lacks details about pagination, result field descriptions, or any constraints, which would be helpful given 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?

Explains 'items' parameter as an array of connection selectors (item_id uuid, connector_id, or connector_name), adding rich meaning to the schema which only specifies array of strings. With 0% schema coverage, description compensates effectively.

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 identifies the tool as listing loan contracts per bank connection, specifies the HTTP endpoint, and uses the specific verb and resource. Distinguishes from sibling list tools by focusing on 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?

Explicitly describes when to use 'items' parameter for specific connections versus omitting for all banks. Mentions rate-limit spacing. But does not explicitly compare to alternative tools for other financial data.

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

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

Beyond annotations (readOnly, idempotent), the description details auto-pagination up to 5000, truncated warnings, upstream error handling, credit card pending/posted behavior, sparse billId hints, and provider_incident blocks. This far exceeds what annotations alone provide.

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

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

The description is long but well-structured, starting with the core purpose then detailing parameters, pagination, and caveats. While some information is repeated (e.g., billId hints mentioned twice), the overall structure supports quick comprehension by an AI agent.

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

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

Given the tool's complexity (8 parameters, no output schema, credit card nuances), the description is remarkably complete. It covers pagination, error handling, bulk support, credit card metadata, provider incidents, and cross-references sibling tools for required supplementary data.

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 each parameter: from/to date format, search_queries behavior (case-insensitive subset, OR semantics), detail levels (compact/rich/raw) with what each returns, pagination semantics, and bulk account_ids. Every parameter is meaningfully 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 it returns transactions for bank accounts (BANK or CREDIT type) and explicitly distinguishes from sibling tools like openfinance_list_credit_card_bills by noting that for credit cards this is the only way to get itemized transactions. It also differentiates the tool's role in the ecosystem.

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 when-to-use and when-not-to-use guidance: it warns against reconstructing bill totals from transaction billIds and directs to openfinance_list_credit_card_bills for standardized debt totals. It also explains credit card behavior variations per connector and suggests checking connection health if results are empty.

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 readOnlyHint=true and destructiveHint=false. Description adds substantial behavioral context: internal account resolution, fan-out, truncation at 5000/account, provider_incident block, and details on compact vs raw modes. 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 lengthy but well-structured with key info upfront. Each sentence adds value. Slight improvement possible with bullet points for parameter 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 7 parameters, the description is remarkably complete, covering return structure, truncation, incident handling, and enrichment options. Leaves very little ambiguous.

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

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

Despite 0% schema coverage, the description thoroughly explains all parameters: item (connector_id/name/item_id or omit), from/to (ISO dates), granularity, detail, type, and top_n (implied). Also explains behavior for each value.

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

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

The description clearly states it performs consolidated cash-flow analysis for a whole bank connection. It explicitly differentiates from siblings like openfinance_list_accounts by stating no need to call that tool first, and describes the output for different granularities.

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 use cases (e.g., 'análise anual/mensal', fluxo de caixa) and guidance on when to use raw granularity and detail options. Also mentions truncation and provider incidents. Lacks explicit negative usage cases but overall strong.

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. The description adds context about LIVE checks, return fields (global indicator, degraded components, incidents, your_banks_affected), and the ability to distinguish provider-side problems. No contradictions.

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

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

Three sentences each earning their place: first states core purpose, second gives usage scenario, third details output. No redundant words. 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 thoroughly explains what the tool returns (global indicator, degraded components, incidents, your_banks_affected). For a zero-parameter tool, this is complete and helps an agent understand the output without additional documentation.

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 schema coverage is 100%. The description does not need to add param info; the baseline of 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?

Clearly states it checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling tool openfinance_get_item_status. The verb 'Checks' and resource 'operational status' are specific, and the description explains its distinct 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?

Explicitly describes when to use the tool: when data looks incomplete or stale despite a connection showing UPDATED. It contrasts with openfinance_get_item_status and explains what it reveals (upstream outage vs connection problem). No explicit when-not instructions, 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 indicate readOnly, idempotent, and nondestructive hints. The description adds valuable behavioral details: it returns a connect_url, filters based on user's plan, and includes a caveat warning for non-Open-Finance connectors that require manual reconnection. This goes beyond the annotations.

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

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

The description is a single, well-organized paragraph that starts with the tool's purpose, then details its return values, caveats, and usage order. It is concise with 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 the tool has 2 parameters and no output schema, the description thoroughly explains what is returned and the caveats. It provides enough context for an AI agent to use it correctly, though it could mention potential error cases or pagination.

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 is described as an array of strings with examples, and it is emphasized as REQUIRED (despite schema showing optional) because without it the tool returns a hint. include_accounts is mentioned as controlling whether accounts are included. This adds 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 that the tool searches available bank connectors by name, and specifies what it returns (connector id, access type, audience, linked connections, connect_url). It distinguishes from sibling tools like 'connect' and 'list_connections' by focusing on searching the catalog of available connectors and providing a pre-selected connect_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 explicitly instructs to call this tool 'BEFORE connecting' to obtain a one-click link. It also mentions that keywords[] is required, otherwise it returns a hint, and explains that the tool honors the user's plan (PF hides PJ banks). This provides clear guidance on when and how to use the tool.

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

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

The description goes beyond annotations by disclosing key behavioral traits: it overrides automatic categorization, creates a Category Rule for future similar transactions, and explains the batch error handling (per-item errors do not fail the whole batch). Annotations only indicate non-read-only and non-destructive hints, making the description essential for understanding side effects.

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 and front-loaded, starting with the core purpose. Every sentence adds value: usage guidance, behavioral effects, and batch response format. No superfluous content.

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

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

Given the tool's complexity, the description covers input requirements, side effects, and output format comprehensively. Despite no output schema, the description provides a clear return structure with fields for updated, results, and errors. This makes the tool fully understandable for correct 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?

With 0% schema description coverage, the description fully compensates by explaining the `items` parameter as an array of { transaction_id, category_id } and specifying the sources for both IDs. It also details the return shape, adding complete semantic 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 purpose: 'Corrects the category of one or more transactions' and specifies the HTTP method (PATCH /transactions/:id). It distinguishes itself from sibling tools by detailing the specific operation and required parameters.

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 context for when to use the tool: to fix miscategorized transactions and improve categorization accuracy. It explains how to obtain the required IDs from other tools (openfinance_list_transactions and openfinance_list_categories). However, it does not explicitly mention when not to use alternatives, though no direct alternatives exist.

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 state idempotentHint=true, meaning repeated calls should be safe. The description adds that the conversation array is needed for reproduction, which is useful but does not further elaborate on behavioral traits like network effects or error handling.

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 immediately states the purpose and then provides a crucial usage instruction. No 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 the tool's simplicity (3 parameters, no output schema, annotations provided), the description covers the essential information: purpose and required input (conversation). It could be enhanced by noting the expected format of the conversation array but is otherwise 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?

With 0% schema description coverage, the description must compensate. It explains the conversation parameter partially ('Include the conversation array') but does not specify that it should be a JSON string or clarify the 'context' parameter. This leaves gaps in parameter understanding.

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

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

The description clearly identifies the tool's purpose: 'Report a bug, missing feature, or send feedback.' It uses a specific verb and resource, and is distinctly different from sibling tools which focus on financial operations and system utilities.

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 usage: 'Include the conversation array with recent messages for reproduction.' While it doesn't explicitly state when not to use this tool, the purpose is clear enough that an agent can infer when to invoke 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, destructiveHint=false. The description adds value by specifying that it shows both platform and adapter versions, which is behavioral context beyond the annotations.

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

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

The description is a single, efficient sentence with no redundant words. It is front-loaded and 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 the tool has no parameters and no output schema, the description is fully complete. It tells exactly what the tool does without omissions.

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

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

There are zero parameters and schema coverage is 100% (empty). With no parameters, baseline is 4. The description does not need to add parameter information.

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

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

The description clearly states the tool shows 'MCP platform and adapter versions', using a specific verb and resource. It distinguishes itself from sibling tools like openfinance functions or authentication 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?

While no explicit when-to-use or when-not-to-use guidance is given, the tool is simple and self-explanatory. The description implies it should be used to retrieve version information, which is clear given the context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description does not need to repeat those. It adds value by specifying the exact content of the return (installed MCPs, connection status, catalog tool counts), which goes beyond the 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?

The description is a single sentence that clearly and completely conveys the tool's purpose without unnecessary words. It is front-loaded and easy to parse.

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

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

Given the tool has no parameters and no output schema, the description captures the essential information about what the tool returns. It is complete enough for an agent to understand its function, though a note on the structure of the return (e.g., JSON format) could be beneficial but is not 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, and the schema coverage is 100% (since there are no parameters to describe). The description does not need to add parameter details. Baseline score of 4 is appropriate.

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

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

The description clearly states the tool returns the toolkit state, including installed MCPs, connection status, and catalog tool counts. It uses a specific verb ('returns') and resource ('current toolkit state'), and it distinguishes itself from the sibling tools (e.g., openfinance tools, show_version) by focusing on system introspection.

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 does not explicitly state when to use this tool versus alternatives. However, it is a simple read-only info tool, and its purpose is self-evident. No exclusions or alternative mentions are provided, but the context signals suggest it is the only introspective tool among siblings.

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