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?

Although annotations already declare readOnlyHint, idempotentHint, and destructiveHint, the description adds valuable behavioral detail: balances are snapshots tied to upstream sync, not live reads; rows may degrade with realtime:false; credit accounts may return structured warnings rather than throwing. Nothing contradicts 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 long but every sentence earns its place by covering snapshot semantics, sync guidance, error modes, degraded rows, and response shape. It is front-loaded with the core purpose and endpoint before adding edge-case detail.

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 there is no output schema, the description fully compensates by documenting the response shape, error rows, warning behavior, degraded response fields, and the relevant failure modes. An agent has enough information to call this tool correctly and interpret common outcomes.

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

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

Schema coverage is 0%, so the description must compensate, and it does by specifying that account_ids is an array of 1–50 items. It does not detail the exact string format of each account ID, but the sibling tool context and the endpoint path make the semantics clear enough.

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 begins with a specific verb and resource: 'Returns the latest available balance per account id' and even cites the endpoint. It clearly differentiates this from siblings like openfinance_list_accounts and openfinance_get_accounts_detail by focusing on balance freshness and snapshot semantics.

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 tells the agent when to use this tool and when to switch to openfinance_force_sync, e.g., when a movement is missing or the balance disagrees with the sum of transactions. It also covers error-driven fallback behavior, leaving no ambiguity about when this tool is 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 already mark this as read-only and idempotent, and the description adds substantial behavioral context: the opt-in scan cost, transactions_basis semantics, the authoritative nature of totalAmount, the payments[] cycle caveat, and the warning about whether payments imply paid status. This goes far beyond the minimal 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?

The description is long but every major section adds genuine decision value: when to opt in, how to interpret basis values, what not to recompute, and how to avoid misreading payments[]. The main purpose is front-loaded, though a somewhat tighter structure could have made the details easier to consume.

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 complex optional behavior, no output schema, and 0% schema parameter coverage, the description covers the return shape, batch error shape, estimated vs exact transaction matching, direct alternatives, and common pitfalls. This is a complete agent-facing contract.

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 carries the burden. It explains bill_ids as an array needing discovery, clarifies what include_transactions does, and explains why account_id is needed. However, transactions_detail with its compact/rich/raw enum is never described, leaving an optional but meaningful parameter unexplained.

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

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

The description opens with a specific verb and resource: 'Returns bill-level detail for one or more credit card bills by id (GET /bills/:id)'. It names concrete fields and the bill vs. transaction boundary, which distinguishes it clearly from listing all bills or fetching 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 explicitly tells the agent when to use the optional transactions mode, how to discover bill_ids via openfinance_list_credit_card_bills, and to prefer openfinance_list_credit_card_bills for paid status. This provides both positive usage and clear routing 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?

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 already mark the tool read-only and idempotent, and the description adds substantial non-obvious behavior: account name is the legal issuer, not the brand; credit balance meaning is connector-dependent; balance_notice indicates a misleading zero; bankData fields can lag; provider_incident and identity_notice affect how values must be interpreted. None of this contradicts 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 long, but nearly every clause carries operational value and the core purpose is front-loaded. It loses a point because the caveats are written as dense prose paragraphs rather than being structured into scannable bullets or sections.

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

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

For a read-only list tool with no output schema and complex domain semantics, this description covers return fields, bank-name semantics, credit-balance pitfalls, incident/notice interpretation, dedupe rules, and parameter routing. Together with the annotations, it gives an agent everything needed to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `item` targeting and omitting behavior, `item_ids` for bulk execution, and the BANK/CREDIT distinction that maps to `type`. However, `item_id` is never explained, and the filtering effect of `type` is only implied through the return-value wording rather than stated 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 first sentence clearly identifies the operation and resource: it returns accounts for a bank connection and enumerates BANK vs CREDIT plus the returned fields. The description further sharpens the purpose by distinguishing all-linked-banks mode from single-bank mode. This is specific, non-tautological, and distinct from sibling tools.

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

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

It gives explicit routing guidance: 'OMIT item to list accounts across ALL linked banks... use this when the user asks for my accounts/cards without naming a bank' and 'Pass item to target a single bank.' It also redirects to openfinance_list_credit_card_bills for standardized bill amounts and warns not to tell the user a card has nothing to pay when balance_notice is present. This is strong when-to-use and alternative coverage.

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 annotations already flag the tool as read-only, idempotent, and non-destructive, but the description adds substantial behavioral disclosure: auto-pagination, manual pagination, the 5000 ceiling, truncation signals, scheduled installments being returned at the top of date-descending lists, per-connector billId sparsity, one server returns an error envelope instead of throwing, and possible provider_incident blocks. These are exactly the behaviors an agent would not otherwise know.

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, clearly written, and internally separated with capitalised sections, but it is substantially longer than necessary. The same billId caveat and the advice to use the bill's totalAmount appear twice, and secondary detail about rich cards metadata is repeated. Every sentence earns some place, but the overall package could have been tightened without losing meaning.

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 output schema, the description is exceptionally complete. It tells the agent which response fields to expect, with the account echo, scheduled_count, notice, truncated and warning flags, error response shape, per-connector variability, and provider_incident. It also suggests follow-up tools for statement dates, stale credit card sync, and connection health, so there is no major context gap.

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 takes on the full burden of explaining the parameters. It does this well: from/to, search_queries, page, page_size, detail, and the implications of each are defined operationally. However, account_ids is left unexplored and its distinction from account_id is not explained, leaving one parameter under-documented.

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

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

The description starts with a specific verb and resource: 'Returns transactions for a bank account (BANK or CREDIT type)', and immediately distinguishes the scope by saying this is the ONLY way to get itemized credit card transactions. It also explicitly name-drops and differentiates sibling tools such as openfinance_list_credit_card_bills and openfinance_list_accounts, so purpose and boundaries are 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 gives explicit criteria for when to use this tool versus alternatives: use openfinance_list_credit_card_bills for the authoritative bill total, pass `to` to avoid scheduled rows, narrow from/to when truncated is returned, and check openfinance_get_item_status when a CREDIT account yields zero transactions. These exclusions and alternatives are stated directly, so an agent does not have to infer usage.

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

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

Annotations already indicate 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.