Rico MCP

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

Adds context beyond annotations: explains that calling with no args returns login link, and that token is a JWT. Annotations already indicate idempotent read, which is consistent.

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 and method, 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?

Fully describes both usage patterns given simple nature and 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 coverage is 0%, but description explains the token parameter is a JWT pasted by user, adding meaning where schema lacks.

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 specifies the tool is for authentication with two distinct methods (config for permanent, token for session). Distinguishes from sibling tools like connect and marketplace.

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

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

Explains when to use config vs session, and that calling with no args returns a link. Lacks explicit when-not-to-use or exclusion of 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:true, idempotentHint:true, and destructiveHint:false, so the safety profile is covered. The description adds valuable context by detailing the two possible response scenarios (connected vs missing credentials), which 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 two sentences long, front-loads the purpose, and each sentence adds essential information. There is no waste.

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

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

For a simple zero-parameter status check tool without an output schema, the description fully explains what is returned in both normal and error states. It is complete and leaves no ambiguity.

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

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

The tool has zero parameters, and schema coverage is 100%. The description does not need to explain parameters. Baseline for 0 parameters is 4, and no additional parameter information is necessary.

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 connection status and URLs, and it distinguishes between two states: when all providers are connected (authenticated:true, empty pending[]) and when credentials are missing (returns connect_url). This provides a specific verb and resource with clear output behavior, differentiating it from sibling tools like 'authenticate'.

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

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

The description implies the tool should be used to check connection status, but it does not explicitly state when not to use it or mention alternatives. However, given the context of sibling tools like 'authenticate', the usage context is clear enough.

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

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

Beyond the sparse annotations (readOnlyHint=false, openWorldHint=true), the description discloses key behavioral traits: invoke runs one-off without installing or bloating the tool list, returns connect links when credentials are needed and checkout links when payment is required (with 'retry' instruction), flags installed_in_toolkit vs workspace, and requires owner/admin for writes. 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 long but information-dense and logically structured, moving from core flow to key distinctions to prompt library. It front-loads the primary purpose and uses a natural narrative. However, it is a dense wall of text that could benefit from bullet points or clearer section separation, and some redundancy exists (e.g., 'installed_in_toolkit vs installed_in_workspace' appears twice).

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 of this complexity (14 actions, 23 params, no output schema, minimal annotations), the description covers an impressive amount: the end-to-end workflow, auth/payment behavior, permission model, installed status flags, and the prompt library. Gaps remain: the 'resume' action is never mentioned, and parameters like immediate and tier_slug are absent. Yet overall it provides a strong operational context for an agent.

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

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

With 23 parameters and 0% schema description coverage, the description must compensate, but it only explains the 'action' parameter thoroughly and touches on mcp_id, tool_id, and prompt_slug implicitly. It does not explain key parameters like arguments, immediate, tier_slug, prompt_vars, cancel_reason, report_context, or request_details. This leaves agents guessing about the meaning and expected formats of most 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 explicitly states the tool is the 'official mcp.ai marketplace' — the central catalog and runtime for every MCP/tool. It clearly enumerates its purpose (search, describe, invoke, install, subscribe, prompt library) and differentiates it from the OpenFinance siblings, which are domain-specific. The verb 'catalog and run' plus the action list make the purpose unambiguous.

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

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

The description provides explicit when-to-use guidance: the core flow (search → describe → invoke), when to prefer invoke over install ('Use install only to make an MCP PERMANENT... prefer invoke for a single/occasional use'), and permission requirements ('Writes require workspace owner/admin'). It also states what list_tools is for and how to handle credential/payment fallback. This is a model of usage direction.

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 accurately reflects the destructive nature consistent with annotations (destructiveHint=true), explicitly stating it deletes data and data becomes unavailable. It also discloses the return of a reconnection URL. No contradiction with annotations.

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

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

Two sentences with no wasted words. Front-loaded with the primary action, followed by consequences and return 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?

Considering simple tool with 1 param and no output schema, the description covers action, side effects, and reconnection option. However, lacking parameter explanation leaves a gap; otherwise 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?

The description mentions 'for a specific bank' but does not explain the sole parameter 'item' (e.g., bank ID or connection identifier). With 0% schema description coverage, the description should clarify the parameter's meaning and format.

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 'Revokes the Open Finance consent... and deletes the connection data', specifying the resource (bank) and action (disconnect). It distinguishes from sibling tools like openfinance_force_sync (sync) or openfinance_get_* (read) by focusing on removal.

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 result of using the tool ('data will no longer be available') and mentions a reconnection possibility via add_connection_url. However, it does not explicitly state when not to use it or compare to alternatives like openfinance_list_connections for reviewing connections first.

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

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

The description discloses that the tool waits up to ~60s, returns a specific result structure, handles needs_action with a reconnect_url, and times out with a fallback to get_item_status. This adds significant detail beyond annotations, which only indicate non-readonly and 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 well-structured with front-loaded purpose, followed by parameter details, return values, and error handling. While somewhat lengthy, every sentence adds value, so it is appropriately concise for the tool's complexity.

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

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

Despite no output schema, the description thoroughly explains the return object with status, executionStatus, lastUpdatedAt, synced, and error conditions like needs_action and timed_out. It covers both synchronous and asynchronous modes, making it complete.

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

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

The description adds extensive meaning to the two parameters: explains wait boolean with default behavior and items array with selector types (item_id, connector_name, etc.) and omission for all. Given 0% schema description coverage, this is essential and well-done.

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 sync of bank connections, specifying the verb 'forces' and the resource 'connections'. It distinguishes from siblings like openfinance_get_item_status by explaining that this tool waits for the sync to finish.

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 when balances look stale and explains that it pulls fresh data without disconnecting. It provides guidance on omitting items for all banks and setting wait: false for fire-and-forget. However, it does not explicitly list alternatives to avoid.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description discloses critical behaviors: partial error handling via warnings for CREDIT accounts, degradation to last-synced data with realtime: false when upstream fails, and the response shape. This fully informs the agent of edge cases.

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. It begins with the main action, then details constraints, error scenarios, and response format. Every sentence adds value, though it is longer than strictly necessary.

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

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

Given the complexity of balance retrieval with error degradation and the lack of output schema, the description covers all necessary behavioral and response details. It is sufficient 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 schema has 0% description coverage, but the description adds the array size constraint (1–50) and implies the format as account IDs. This is useful but does not fully compensate for the lack of schema-level 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 it returns real-time balance per account ID and mentions the REST endpoint. The tool's purpose as a balance fetcher is unambiguous and distinct from sibling tools like openfinance_get_accounts_detail or 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?

There is no explicit guidance on when to use this tool versus alternatives. The description focuses on behavior but does not advise against using it for non-balance queries or when other tools might be more appropriate.

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 the batch response shape (results, errors), the provider_incident block, and data reliability concerns, which goes beyond the readOnlyHint and idempotentHint annotations. No contradiction.

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

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

The description is concise with two main sentences and a cautionary note, each sentence earning its place. Front-loaded with the core purpose.

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

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

Given no output schema, the description adequately explains the return shape and potential edge cases (provider_incident). It covers the single required parameter and distinguishes from siblings.

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

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

The description adds meaning to the single parameter by stating it is an array with 1-50 items, which is not in the schema (coverage 0%). This helps the agent understand constraints.

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

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

The description clearly states it returns full account objects with extended creditData per ID, and specifies the batch shape and provider incident warning. This distinguishes it from sibling tools like openfinance_list_accounts which only lists 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?

Provides guidance on passing account_ids as an array of 1-50 items and warns about unreliable data during provider incidents. However, it does not explicitly state when to use this tool over alternatives like get_account_balance.

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

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

Annotations show readOnlyHint=true and idempotentHint=true. The description adds crucial behavioral traits: batch output shape, no paid/status field, payments[] likely from previous bill, creditCardMetadata.billId is sparse/inconsistent. 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 relatively long but each sentence adds value. Front-loaded with main purpose, then restrictions, usage guidance, and caveats. Well-structured but could be slightly 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 domain complexity (credit card bills, payments, transactions) and lack of output schema, the description covers all necessary details: what fields return, batch shape, relationship with transactions, payment ambiguity, paid status, and alternative tools. Complete for agent use.

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

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

Only one parameter (bill_ids) with 0% schema description coverage. The description explains it's an array and advises discovery via sibling tool. Provides clear usage context but could specify id format or origin more explicitly.

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

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

The description explicitly states it returns bill-level detail (financeCharges and payments) by id, and clearly distinguishes what it does NOT return (individual transactions) with a specific sibling tool reference (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?

Provides explicit when-to-use (get bill detail) and when-not-to-use (do not reconstruct bill total by summing transactions, use openfinance_list_credit_card_bills first to discover ids). Also gives alternative for itemized transactions and paid status.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds valuable context: the reconnect_url behavior and that it avoids consuming a connection slot. It also explains bulk return structure. 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 concise (two sentences) and front-loaded with the main purpose. It covers both single and bulk use efficiently. Minor improvement could be bullet points for clarity.

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

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

Despite no output schema, the description lists all relevant return fields (status, executionStatus, connector metadata, reconnect_url, count, items) and covers both single and bulk cases. It sufficiently informs an agent about what to expect.

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

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

With 0% schema description coverage, the description fully explains the parameters: 'item' for single, omit for all, 'item_ids' for batch. It does not clarify the difference between 'item' and 'item_id', but overall meaning is clear.

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

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

The description explicitly states it returns the status of a bank connection, lists possible values (UPDATED, UPDATING, LOGIN_ERROR), and details other return fields. It clearly distinguishes between fetching a single connection or all connections, which separates 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 provides clear instructions: omit 'item' for all banks, pass 'item' for single bank, and use 'item_ids' for bulk. It lacks explicit when-not-to-use or alternatives, but the use case is straightforward for a status check.

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. Description adds batch processing details, range of loan_ids (1-50), and response format, exceeding annotation coverage.

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

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

Concise and front-loaded with purpose and usage. Contains additional technical details but remains readable.

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?

Detailed enumeration of returned fields compensates for missing output schema. Provides enough context for an AI agent to understand the full contract detail.

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 one required array field; description adds clarity 'Pass `loan_ids` as an array (1-50)'. With 0% schema coverage, this provides essential guidance.

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 full loan contract detail by ID, listing specific fields (interest rates, charges, payments, etc.). Distinct from sibling 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' and specifies batch shape with { results, errors }.

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 readOnly=true and idempotent=true; description adds that response may contain provider_incident and identity_notice blocks, explains credit balance connector-dependence, and mentions bulk support via item_ids. 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 lengthy but every sentence adds value. Well-structured with paragraphs for different behaviors. Could be slightly more concise but front-loaded with the main action.

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 exists, so description fully explains returned fields (balance, number, type, etc.), special blocks (provider_incident, identity_notice), and the meaning of credit balance. Covers all necessary context for a tool with 4 parameters and 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 coverage is 0% but description explains most parameters: item (single bank targeting), type (filter), and item_ids (bulk). However, item_id is not explained (likely redundant with item). Still adds substantial 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?

Specifically states it returns accounts for a bank connection, differentiating by type (BANK/CREDIT) and listing returned fields. Distinguishes from sibling tools like openfinance_list_credit_card_bills by explaining when to use that tool instead.

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 omit vs. pass item parameter, warns about credit balance interpretation, explains provider_incident and identity_notice handling, and directs to alternative tool for standardized bill amounts.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint=false. The description adds behavioral context beyond annotations: it is cached for the session, returns a single aggregated response with no batch ids, and specifies the response structure (e.g., `descriptionTranslated` for pt-BR users). 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 two sentences: first sentence states purpose and caching, second details response fields and usage hint. No wasted words, front-loaded with the primary action.

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 no parameters, no output schema, and clear annotations, the description fully explains what the tool returns, how it behaves (cached, single response), and its relation to another tool. It is complete and actionable.

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 no parameters, so the description does not need to add parameter meaning. Baseline for 0 parameters is 4, and the description appropriately focuses on the response rather than 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 explicitly states the tool returns 'Pluggy's transaction category taxonomy' with a specific verb (Returns) and resource (GET /categories). It details each field in the response, including `id` used by a sibling tool, which differentiates it from other list tools like openfinance_list_transactions.

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

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

The description implies usage context by noting that `id` is used by openfinance_update_transaction_category, guiding the agent to use this tool before calling the update tool. However, it lacks explicit when-to-use/when-not-to-use or 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 declare readOnlyHint=true and destructiveHint=false. Description adds behavioral context about reconnect_url opening UPDATE mode, not requiring disconnection, and not consuming a slot. No contradictions with annotations.

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

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

Description is fairly concise, but the single paragraph is dense. It could be broken into sentences for readability, but it contains no extra fluff. Front-loads the core purpose.

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

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

Given no output schema, description lists returned fields (connector_id, item_id, bank name, URLs). It explains the behavior of reconnect_url sufficiently. With 26 sibling tools, the description is complete enough for a listing 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?

Input schema has 0 parameters, so description need not add parameter info. Baseline 4 is appropriate; description provides no parameter details, but none are 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?

Description clearly states it returns saved bank connections with connector_id, item_id, bank name, and URLs. It distinguishes from siblings by explaining the specific URLs (reconnect_url, add_connection_url) and their use cases, e.g., 'use it when a connection needs re-authentication'.

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

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

Provides clear context for when to use reconnect_url (MFA, LOGIN_ERROR, stale data) and notes it does not consume a connection slot. However, it does not explicitly contrast with sibling tools like openfinance_disconnect_bank or openfinance_list_accounts, leaving some room for improvement.

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 complex derived fields (payment_status logic, cycle dates), connector asymmetry (open bill not retrievable), and edge cases (payments landing on next bill, PAST_DUE_UNCONFIRMED). Annotations (readOnlyHint) are consistent and description adds significant behavioral context beyond them.

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

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

Description is extremely detailed and covers many edge cases, which is valuable for this complex domain. However, it is verbose and could be more condensed without losing essential information. The structure is logical (main purpose, then details, warnings, alternatives) but the length may hinder quick parsing 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 complexity (no output schema, 5 parameters, no enumerated values), the description covers all critical aspects: payload structure, derived fields, payment cycle nuances, connector limitations, cross-checking advice, and caveats for transaction-level queries. It provides everything needed for correct invocation and interpretation.

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 carries full burden. It thoroughly explains include_open_bill (opt-in behavior, derived fields) and account_ids (bulk). Pagination parameters (page, page_size) are not described but are standard. account_id is implied but not explicitly defined, though context makes it clear. Overall adds meaningful semantics for key parameters.

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

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

The description clearly states it returns CLOSED credit card bills for CREDIT-type accounts, listing key fields and derived attributes. It distinguishes from related tools like openfinance_list_transactions and openfinance_get_credit_card_bill by specifying scope (closed bills vs. individual transactions vs. single bill detail) and not duplicating sibling behavior.

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

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

Provides explicit when-to-use guidance: opt-in include_open_bill for open bill/total debt, use openfinance_list_transactions for itemized charges, and warns against summing by billId for totals. Explains connector-dependent behavior (open bill availability) and when to rely on bank app. No ambiguity on usage 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 indicate read-only and idempotent behavior. The description adds transparency about error handling (returns fallback on 403) and data integrity checks for mass zeroing, including the data_integrity_warning flag. This goes beyond annotations, though pagination behavior is not discussed.

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

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

The description is front-loaded with the main purpose and includes necessary details about error handling and data integrity. While slightly lengthy, each sentence provides value. It could be more concise but 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 (6 parameters, no output schema), the description covers key aspects: return fields (balance, amount, etc.), error behavior, data integrity warnings, and bulk support. Missing details on pagination and parameter explanations are minor gaps, but overall it provides sufficient context for an AI agent.

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

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

The input schema has 6 parameters with 0% schema description coverage. The description only briefly explains the item_ids parameter for batched execution, leaving the purpose of item, page, type, and page_size unclear. It fails to add sufficient meaning beyond parameter names and types.

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

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

The description clearly states the tool returns an investment portfolio for a connection, listing specific asset types like FIIs, stocks, ETFs, etc. This distinguishes it from sibling tools like openfinance_list_investment_transactions and openfinance_get_account_balance by detailing the scope and unique features such as data integrity warnings.

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 by specifying it returns portfolio for a connection and handles errors gracefully (returning a warning instead of throwing). It also mentions bulk support via item_ids. However, it does not explicitly state when to use this tool over alternatives or provide conditions for not using 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value by detailing the transaction list structure, including expenses breakdown, and bulk execution capability, which are not covered by annotations. No contradiction.

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

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

Two well-structured sentences: first sentence dense but covers core functionality and returned fields, second sentence provides usage guidance. No fluff, every sentence adds value.

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

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

Given the absence of output schema, the description thoroughly enumerates return fields (quantity, value, amount, netAmount, agreedRate, brokerageNumber, expenses). It also explains bulk support and prerequisite tool usage, ensuring the agent has sufficient context to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the purpose of investment_id and investment_ids, but does not describe page or page_size parameters. This leaves gap for pagination parameters, resulting in partial 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 it returns movement history for a specific investment position, enumerating transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER) and key fields. It is easily distinguishable from sibling tools like openfinance_list_investments 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?

Explicitly advises using this tool after openfinance_list_investments to obtain the investment_id, and mentions bulk support via investment_ids. However, it does not explicitly state when to avoid this tool or compare it directly to 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?

Description adds sequential querying with rate-limit spacing and return format '{ results, errors }', which is beyond readOnly/idempotent annotations. Still, no mention of pagination or limits.

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 efficient sentences: purpose, items specification, omit behavior. No waste, front-loaded with main action.

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 usage and return structure without output schema. Lacks details on pagination or error handling, but sufficient for a list tool.

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

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

Schema has 0% coverage for the 'items' parameter. Description fully compensates by explaining items as connection selectors with valid types and behavior when omitted, adding critical 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?

Clearly states it lists loan contracts per bank connection with the HTTP endpoint. Distinguishes from sibling get_loan_detail by focusing on listing multiple loans per connection.

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

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

Explains two modes: with items for specific connections or omit for all. Implicitly contrasts with get_loan_detail for single loans, but lacks explicit when-not or alternative references.

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 far beyond annotations (readOnlyHint, idempotentHint, destructiveHint) by detailing behaviors such as upstream error handling (returns {total:0, results:[], warning, error}), auto-pagination, the 5000 ceiling and truncated flag, variation in credit card pending/posted status by connector, and the provider_incident block. No contradictions with annotations.

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

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

The description is very long but efficiently packed with essential information. It is front-loaded with purpose and then dives into details. However, it could be better structured (e.g., using bullet points for pagination modes) to improve readability without losing content.

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

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

Despite no output schema, the description thoroughly explains the response structure (account echo, transactions list, pagination metadata, warning, error, provider_incident block) and the meaning of fields like truncated, total, and detail levels. It covers all edge cases and usage contexts, making it exceptionally complete 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 has 0% description coverage, but the description compensates fully by explaining each parameter: account_id (required), from/to (ISO dates), detail (enum with compact/rich/raw and what each yields), page/page_size (manual vs auto), search_queries (case-insensitive substring match, OR semantics), and account_ids (bulk support). Adds significant meaning beyond the schema.

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

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

The description clearly states it returns transactions for a bank account (BANK or CREDIT type) and highlights that for CREDIT accounts it is the ONLY way to get itemized transactions, distinguishing it from siblings like openfinance_list_transactions_by_item and openfinance_get_account_balance.

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

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

The description provides extensive usage guidance: when to use this tool vs alternatives (e.g., for standardized totals use openfinance_list_credit_card_bills), warns against summing by billId, explains pagination modes, and advises checking item status if total is zero. It also mentions bulk support via account_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 indicate readOnly, idempotent, non-destructive hints. The description adds significant behavioral context: internal account resolution, per-account cap of 5000 with truncation flag, provider incident block, bulk support, and default granularity behavior. 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 lengthy but front-loaded with the core purpose. Every sentence adds value for a complex tool. Could be slightly more concise but remains clear and well-organized.

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

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

Despite no output schema, the description explains the output for default granularity (por_mes, top_despesas, etc.) and mentions truncation and provider incidents. Covers all essential aspects for a tool with 9 optional 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?

With 0% schema coverage, the description fully explains all 9 parameters: item (accepts connector_id, connector_name, item_id), from/to (ISO dates), granularity (monthly/raw with defaults), detail (compact/rich/raw), type (BANK/CREDIT), top_n, item_ids. Default values and output structure are 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 identifies the tool as performing consolidated cash-flow analysis for a bank connection, resolves accounts internally, and distinguishes itself from siblings like openfinance_list_accounts. The verb 'analyze' and resource 'transactions' are explicit.

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

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

Provides explicit guidance on when to use (cash-flow analysis, annual/monthly queries), when not to call other tools (no need for openfinance_list_accounts first), and explains parameter behavior (omit item for all banks, granularity options, detail levels). Also warns about 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 declare readOnlyHint=true, destructiveHint=false. Description adds value by detailing return fields (global indicator, degraded components, incidents, your_banks_affected). No contradictions.

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

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

Two sentences, front-loaded purpose, no fluff. Every sentence earns its place with usage guidance and return 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?

Without output schema, description explains exactly what is returned, covering all important aspects for an agent to interpret results.

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 as description doesn't need to add param info.

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 'Checks the LIVE operational status of the Open Finance provider' and distinguishes from sibling openfinance_get_item_status by specifying this is provider-side health.

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 when to use: when data seems incomplete/stale despite connection showing UPDATED, to diagnose upstream outage or incident. Contrasts with alternative 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?

Annotations already note readOnlyHint=true and idempotentHint=true. The description adds useful details like caveats and plan behavior, but contradicts the input schema by claiming 'keywords' is REQUIRED when schema has no required fields, which is misleading for agents.

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 front-loaded with the main purpose. Every sentence adds value, though it could be slightly trimmed without losing 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 explains key return fields, caveats, and plan behavior. It is thorough for a search tool, but lacks details on error handling or rate limits.

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 adds meaning by giving examples for keywords and explaining include_accounts. However, it does not clearly state allowed formats or that keywords is optional despite claiming it is required.

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 a specific verb ('Searches') and resource ('available bank connectors by name'), clearly distinguishing it from sibling tools like 'connect' or '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?

It explicitly says to call this before connecting and mentions plan behaviors, but does not list when not to use or alternative tools for other search needs. The context is clear but lacks exclusions.

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

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

The description discloses key behavioral traits beyond annotations: it overrides automatic categorization, teaches Pluggy by creating a Category Rule, and explains batch behavior with per-item errors not failing the whole batch. This adds significant 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 relatively long but front-loaded with purpose and includes essential details on side effects and response shape. Every sentence adds value; no unnecessary verbosity, though it could be slightly 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 no output schema and a complex batch update with side effects, the description is highly complete: it covers input structure, side effect (Category Rule creation), batch error handling, and full response shape. No gaps left for an agent to infer.

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 no parameter descriptions (0% coverage), but the tool description explains the structure of the 'items' array, the required fields (transaction_id, category_id), and their sources. This adds useful meaning beyond the raw schema.

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

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

The description clearly states the verb 'Corrects the category of one or more transactions' and specifies the endpoint (PATCH /transactions/:id). It distinguishes from sibling tools by referencing where to obtain transaction_id and category_id (openfinance_list_transactions and openfinance_list_categories), avoiding ambiguity.

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: 'use this to fix miscategorized transactions' and explains the side effect of creating a Category Rule, guiding appropriate use. However, it does not explicitly state when not 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?

Annotations show idempotentHint=true and destructiveHint=false, but the description adds no behavioral details (e.g., what happens after submission, required permissions). Given the annotations, the description's value is minimal.

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

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

Two concise sentences, front-loaded with purpose and usage hint. No wasted words.

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

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

For a simple bug report tool with no output schema, the description covers the essential behavior and a key parameter tip. It lacks return value info but is 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?

Schema description coverage is 0%, so the description must compensate. It explains the conversation parameter's purpose for reproduction, but leaves context and message undefined. Partial coverage earns a 3.

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. It distinguishes from sibling tools which are mostly OpenFinance operations, making it the only general feedback 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?

The description advises including the conversation array for reproduction, giving context for when to use it. However, it lacks explicit when-not-to-use instructions or alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description adds no new behavioral traits beyond stating it 'Show's information. This is acceptable but offers minimal extra value.

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, clear sentence with no wasted words. It is perfectly sized for the tool's simplicity.

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

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

The tool has no parameters and no output schema, but the description fully captures its purpose. No additional context is necessary for an agent to use it correctly.

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

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

Zero parameters and 100% schema description coverage mean the description does not need to explain parameters. Baseline is 4.

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

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

The description uses specific verb 'Show' and identifies the resource as 'current MCP platform and adapter versions'. It clearly distinguishes from sibling tools, all of which have different purposes.

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 version information, which is straightforward. No explicit when-not-to-use or alternatives are needed given the tool's simplicity, but the lack of any guidance prevents a perfect score.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by disclosing exactly what state information is returned, which goes beyond the bare 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?

A single, well-structured sentence that front-loads the verb and resource, then enumerates the return contents. No filler or redundant phrases.

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

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

For a zero-parameter, read-only info tool, the description fully explains what the agent will receive. Since there is no output schema, listing the expected fields (installed MCPs, connection status, accounts, catalog tool counts) is sufficient.

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

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

With zero parameters, the schema is trivially complete (100% coverage). The baseline of 4 applies, and there is no parameter ambiguity to clarify.

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

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

The description uses a specific verb ('Returns') and names the exact resource ('current toolkit state'), listing concrete elements: installed MCPs, connection status, connected accounts, and catalog tool counts. It clearly distinguishes this informational tool from the operational 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 context clearly implies this is the tool to call when an agent needs a snapshot of the toolkit's connectivity and installed services. It doesn't explicitly name alternatives or exclusions, but its unique informational scope makes the usage obvious.

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