PicPay MCP

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

Annotations already indicate idempotent and non-destructive. The description adds context about required user actions (copy token, paste), and behavior when called with no arguments (returns link).

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 slightly verbose but efficiently covers both authentication methods. Front-loaded with purpose and audience.

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

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

Given the simple schema and no output schema, the description adequately covers authentication flows, token format, and no-arg behavior. Lacks return value details but acceptable.

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

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

Schema coverage is 0% but the description thoroughly explains the sole parameter 'token': it's a JWT from browser login, optional for getting link, required for session authentication.

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 authenticates for MCP.AI IDE agents, explaining both permanent and session-based methods. It distinguishes from siblings like connect and marketplace by focusing on user 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?

The description provides explicit instructions for two usage scenarios: adding token to config for permanent access or pasting token for session-only. It does not explicitly exclude alternatives, but the scope is clear.

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

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

Annotations already indicate safe read operation (readOnlyHint=true, destructiveHint=false). Description adds context about response format in different states, providing value beyond annotations.

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

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

Two sentences, front-loaded with main purpose, no wasted words. Efficient and clear.

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

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

Sufficient for a parameterless status check. Explains response format sufficiently even without output schema.

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

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

No parameters, so baseline 4 applies. Description does not need to add parameter 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 it returns connection status and URLs, with examples of scenarios. Does not explicitly differentiate from siblings like 'authenticate' or 'openfinance_list_connections', but purpose is distinct enough.

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

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

Describes output conditions for different states (all connected vs. missing credentials), implying when to use. No explicit guidance on when not to use 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?

Discloses key behaviors: invoke works without installing the MCP, returns connect/checkout links for auth/payment, install makes MCP permanent, writes require owner/admin. No contradiction with annotations (readOnlyHint=false, etc.). The description adds substantial context beyond the annotations.

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

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

The description is a single dense paragraph covering all actions and flows. While informative, it lacks formatting (e.g., bullet points) and front-loading; the core purpose is stated early, but the wealth of detail makes it hard to scan quickly. It could be more structured.

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

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

Given the tool's complexity (13 params, no output schema), the description is incomplete. It does not explain return values for actions (e.g., what does search return? what does invoke return?), nor does it describe the `arguments` parameter format. It assumes familiarity with MCP concepts and omits important usage details for several 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 13 parameters and 0% schema description coverage, the description only partially compensates. It explains the `action` enum and mentions related params (query, mcp_id, tool_id, arguments) in the workflow, but fails to describe `limit`, `immediate`, `tier_slug`, `conversation`, `request_name`, `report_context`, and `request_details`. Agents would lack understanding of these parameters' roles and valid values.

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 defines the tool as 'the official mcp.ai marketplace' and enumerates its core actions (search, describe, invoke, install, etc.), distinguishing it from sibling tools like openfinance_* by establishing it as the primary catalog and execution entry point.

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 'use THIS tool FIRST' before external registries, provides a detailed core flow, and advises when to prefer invoke over install, as well as which actions require workspace owner/admin. This covers both when and when-not to use it.

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

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

Annotations provide destructiveHint=true. Description adds specifics: data is deleted, no longer available, and returns a reconnection URL. No contradictions.

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

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

Two sentences, no wasted words. Front-loaded with action and effect.

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?

Adequately covers purpose and effect for a simple tool. Lacks parameter definition and prerequisites, but overall sufficient given annotations.

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

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

Schema coverage 0% and description does not explain the 'item' parameter. Only implies it identifies a bank. Without description, agent may misinterpret.

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

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

Description clearly states the action (revokes consent, deletes data) and effect (data no longer available). Distinguishes from siblings by focusing on disconnection.

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

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

No explicit guidance on when to use this tool vs alternatives like connect or force_sync. Implied usage is when you want to revoke consent, but no context for selection.

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

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

Discloses behavioral traits beyond annotations: waits up to ~60s, polls until syncing finishes, does not disconnect/reconnect. Explains special states (needs_action, timed_out) and return fields like synced and lastUpdatedAt. Annotations are minimal, so description fully carries the burden.

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?

Front-loaded with key action and results structure. Two sentences pack many details; could be slightly more concise but every sentence earns its place.

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

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

Given no output schema, description fully explains return format and fields (results, errors, status, executionStatus, lastUpdatedAt, synced, needs_action, timed_out). Covers all necessary context for a sync tool with two 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 adds meaning for both parameters: items as an array of selectors (item_id, connector_id, or connector_name) with note that omission syncs all; wait as boolean for fire-and-forget. Lacks precise format for selectors, but sufficiently clear for use.

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 bank to re-sync connections, specifying the action (force sync) and resource (connections). It distinguishes from sibling tools like openfinance_get_item_status by describing the polling behavior and return of final status.

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 when to use: 'when a balance or transaction list looks stale'. Provides alternatives (openfinance_get_item_status for re-checking timed_out results) and explains optional parameters for scoping (items or omit) and synchronous vs fire-and-forget (wait).

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds valuable context: CREDIT accounts may return a warning in results, and the response shape includes an errors array for partial failures. 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?

Three sentences with no fluff. Front-loaded with purpose, followed by key parameter details, special error handling, and response structure. Every sentence earns its place.

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

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

For a simple tool with one parameter and no output schema, the description is thorough: purpose, endpoint, parameter constraints, error case, response shape. Could be improved by briefly noting what the balance payload contains (e.g., amount, currency). But overall very complete.

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

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

Schema has 0% description coverage, so the description must compensate. It explains that account_ids is an array with a size limit of 1-50, but does not specify the format of individual IDs (e.g., string pattern). Partial compensation.

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

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

Clearly states it returns real-time balance per account ID, specifies the REST endpoint, and differentiates from sibling tools like openfinance_list_accounts (which lists accounts without balances) and openfinance_get_accounts_detail (likely more detail without balance focus).

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 parameter constraints (array of 1-50) and behavior for CREDIT accounts (warning instead of error). However, lacks explicit when-to-use guidance compared to alternatives like openfinance_get_accounts_detail or openfinance_list_transactions.

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

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

Description adds context beyond annotations: it specifies the batch shape ({ results, errors }) and the inclusion of extended creditData. Annotations already declare readOnlyHint and idempotentHint, so no contradiction; the description adds useful behavioral details.

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: first states the purpose and key resource, second provides parameter usage and output shape. No unnecessary words, front-loaded with the most important 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 outlines the batch result shape and covers the main functionality (full objects, creditData). It could mention error handling or edge cases, but is adequate for a simple batch-get tool.

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

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

Schema description coverage is 0%, so description must compensate. It does so by stating that account_ids must be an array (1-50), providing the format and size constraint that the schema alone does not convey.

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

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

Description clearly states the tool returns full account objects with extended creditData per ID, using a batch GET endpoint. It distinguishes itself from sibling tools like openfinance_list_accounts by specifying that it provides detailed objects for specific IDs.

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

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

Description provides clear instructions: pass account_ids as an array (1-50). It implies that this tool is for fetching detailed account data by ID, but does not explicitly state when to use it over alternatives or when not to use it.

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

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

Annotations already indicate readOnlyHint, idempotentHint, destructiveHint. The description adds critical behavioral context: Pluggy does not return a paid/status field, payments[] reflects previous bill payments, and suggests using another tool to derive payment_status. 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 front-loaded with the core purpose and is well-structured, though slightly verbose in explaining payments[] behavior. Every sentence adds value, but could be tightened slightly.

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 return fields (financeCharges, payments[] with subfields), batch shape, and caveats. References sibling tools for a complete picture. Fully covers all context needed for a tool with one parameter.

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

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

Schema description coverage is 0%, so description compensates by explaining that bill_ids must be an array, use list tool first to discover ids, and mentions batch shape { results, errors }. 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 that the tool returns bill-level detail for credit card bills by id, listing specific fields (financeCharges, payments[]). It explicitly distinguishes from sibling tools by noting what it does NOT return (individual transactions) and contrasting with 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 guidance on when to use this tool vs alternatives: for itemized transactions, use openfinance_list_transactions with a date range. It also explains how to discover bill_ids via openfinance_list_credit_card_bills and warns about the meaning of payments[] and how to check 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?

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds beyond that: reveals that omitting `item` changes response structure to `{ count, items }`, which is not deducible from schema or 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, no wasted words. The critical information (purpose, dual mode, response structure) is front-loaded and concise.

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

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

Despite no output schema, the description covers the return format for both modes. The tool is simple (one optional param), and the description is complete enough for an agent to use correctly.

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

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

Input schema has 0% description coverage (no parameter descriptions). The description fully compensates by explaining the `item` parameter's role and the effect of its absence, adding essential 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 status of a bank connection, including status types, executionStatus, and connector metadata. It explicitly distinguishes two usage modes (all banks vs single bank), providing specific verb and resource.

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 clear context for when to omit or pass the `item` parameter, but does not mention alternative tools or when not to use this tool. It is precise for its single-parameter behavior.

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 as read-only and idempotent. The description adds critical behavioral context: the ambiguity of CREDIT balance being connector-dependent, the distinction between account `name` (legal entity) and `bank` (brand), and the meaning of creditData fields. 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 information-dense but well-structured, front-loading the core purpose followed by parameter usage and important caveats. Every sentence adds value, and the cross-reference to the sibling tool is efficient.

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

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

Given the tool has no output schema and only two optional parameters, the description provides complete coverage: explains return fields, parameter behavior, type-specific data, and links to related tool for further detail. No gaps.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining the `item` parameter (omit for all, pass for single bank) and the `type` parameter (BANK vs CREDIT) along with their associated return fields. Adds meaning beyond the schema's bare definitions.

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 accounts for bank connections, listing specific data fields for BANK and CREDIT types. It also distinguishes itself from the sibling openfinance_list_credit_card_bills by directing users to that tool for standardized bill amounts, thus clarifying its own scope.

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 explains when to use this tool (for listing accounts from all or a single bank) and when not to (for standardized bill amounts, use openfinance_list_credit_card_bills). Provides guidance on omitting vs passing the `item` parameter.

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 value by detailing caching behavior, field names, and that it returns a single aggregated response with no batch ids. No contradiction with annotations.

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

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

Four sentences, each serving a purpose: main action, caching, field details, and response type. Information is front-loaded and no superfluous content.

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

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

Given zero parameters and no output schema, the description fully covers what the tool returns (id, description, translated, parentId, parentDescription) and its caching behavior. No obvious gaps.

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

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

No parameters are defined in the schema, and schema coverage is 100%. Baseline 4 applies as description does not need to add param info. Description clarifies the return fields but that is not parameter-related.

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 Pluggy's transaction category taxonomy, specifying verb 'Returns' and resource 'transaction category taxonomy'. Distinguishes from sibling tool openfinance_update_transaction_category by noting the `id` field is the categoryId used by that 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?

Explains the tool is cached for the adapter session, implying efficiency for repeated calls. Links to openfinance_update_transaction_category, guiding when to use the category ID. However, does not explicitly state avoidances or alternatives among other list tools.

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

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

Annotations already provide readOnlyHint, idempotentHint, destructiveHint. The description adds value by specifying the returned fields (connector_id, item_id, bank name, add_connection_url) and mentions linking additional banks via the widget, which is behavioral context beyond annotations.

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

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

A single, well-structured sentence that front-loads the purpose and lists key returned fields. No redundant words.

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

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

Given no parameters and no output schema, the description adequately covers the purpose and return fields. However, it could mention if results are paginated or if there are limits, but this is not critical for a simple 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?

No parameters exist (input schema empty), and schema description coverage is 100%. Baseline score of 4 applies as the description does not need to add parameter details.

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

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

The description clearly states it returns saved bank connections with specific fields (connector_id, item_id, bank name, add_connection_url). The verb 'list' and resource 'connections' are unambiguous, and it distinguishes itself from sibling tools like connect or 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?

No explicit guidance on when to use this tool versus alternatives. It implies use for retrieving existing connections, but no exclusions or comparisons to similar tools like openfinance_get_item_status.

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

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

The description discloses numerous behavioral traits beyond the annotations: that Pluggy does not return a paid/status field, how payments are assigned to bills, the logic of derived payment_status, connector asymmetry for open bills, and that the tool returns a warning if the product is not enabled. It does not contradict the readOnlyHint or idempotentHint 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 front-loaded with the core purpose and includes detailed semantics, payment derivations, and edge cases. It is long but every sentence adds value; no redundancy. A slightly more concise structure could improve readability, but it is well-organized and informative.

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

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

Given the tool's complexity, the description covers all aspects: output fields, derived payment_status, open_bill details, connector asymmetry, bulk support, and fallback behavior. It explains what the tool does NOT return and provides cross-references to sibling tools. Despite the absence of an output schema, the description makes the output expectations fully clear.

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 bears the full burden. It explains 'include_open_bill' (default false, opt-in, what it returns) and mentions 'account_ids' for bulk support, but does not document 'page' or 'page_size'. While the detailed context helps infer parameter roles, the lack of explicit descriptions for two parameters limits the score.

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 'Returns CLOSED credit card bills for a CREDIT-type account' and lists specific fields, distinguishing it from sibling tools like openfinance_get_credit_card_bill and openfinance_list_transactions. It also notes the tool returns only bill-level summaries, not individual transactions, making its purpose very clear.

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

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

The description provides extensive guidance on when to use the tool, including important Brazilian Open Finance semantics, how to interpret payments and derived payment_status, and when to use the open_bill opt-in. It explicitly warns about connector asymmetry and advises using openfinance_list_transactions for itemized purchases, offering clear when-to and when-not-to usage advice.

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

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

Annotations already indicate readOnlyHint and destructiveHint, but the description adds valuable behavioral context: it returns a structured response (total, results, warning) instead of throwing on 403 or upstream errors. It also lists specific rate fields (lastMonthRate, annualRate, etc.) that are not in annotations. No contradictions.

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

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

The description is a single paragraph that front-loads the core purpose effectively. It lists asset types, fields, and error handling without excessive verbosity. Minor improvement could be splitting into clearer sections, but overall it is appropriately sized.

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

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

Given no output schema, the description thoroughly details expected fields (balance, amount, rates, dueDate, issuer, etc.) and error handling. However, it lacks explicit parameter documentation, which is a gap for a 4-parameter tool with 0% schema coverage. The investment portfolio context is well covered.

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%, and the description does not explicitly explain the parameters (item, page, type, page_size). It partially compensates by listing asset types (COE, EQUITY, etc.) in the narrative, implying type filtering, but does not clarify the role of item, page, or page_size. This leaves significant ambiguity for the agent.

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

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

The description clearly states it returns an investment portfolio for a connection with the INVESTMENTS product enabled, listing specific asset types (FIIs, stocks, ETFs, etc.) and response fields. It distinguishes from sibling tools like openfinance_list_investment_transactions by specifying the product requirement and the broad portfolio scope.

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

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

The description provides context on when to use the tool (for connections with INVESTMENTS product) and behavior when not enabled (returns a safe error response). However, it does not explicitly mention alternatives or exclusions, leaving some ambiguity compared to siblings like openfinance_list_investment_transactions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds context on return fields and bulk execution, but does not disclose rate limits or authentication specifics. With annotations covering safety, this is adequate.

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 clear paragraphs with no wasted words. Could benefit from a more structured format (e.g., bullet list of fields) but overall efficient and front-loaded with 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?

Covers return fields and prerequisite tool, but lacks explanation of pagination parameters. Given no output schema, the field list helps, but the agent may not know how to paginate results without additional context.

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

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

Schema coverage is 0%, so description must compensate. It explains 'investment_id' (prerequisite) and 'investment_ids' (bulk), but omits 'page' and 'page_size' entirely. Only half the parameters are semantically described.

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

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

The description clearly states it returns movement history for investment positions, lists transaction types (BUY/SELL/etc.), and specific fields returned. It distinguishes from sibling tools by focusing on investment transactions rather than general transactions.

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

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

Explicitly states 'Use after openfinance_list_investments to get the investment_id' and mentions bulk support. However, it does not provide when-not-to-use guidance or compare to other transaction tools.

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), the description adds critical behavioral details: sequential querying with rate-limit spacing, and return format '{ results, errors }' per connection. No contradictions with annotations.

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

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

Three tightly written sentences: purpose first, then parameter usage, then omission case and return format. Every sentence adds value with no redundancy.

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

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

Given the single parameter, no output schema, and good annotations, the description covers purpose, parameter usage, behavioral modes, and return structure. It is self-sufficient for an AI to correctly select and invoke the tool.

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

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

The schema has 0% description coverage and only an array of strings. The description compensates fully by specifying that each string is a connection selector (item_id, connector_id, or connector_name), and explains the optionality and effect of omitting the parameter.

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

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

The description clearly states 'Lists loan contracts per bank connection' and specifies the HTTP path. It distinguishes from sibling tools by focusing on loans, and explains the two modes (with or without 'items') for different scopes.

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

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

The description explicitly tells when to pass 'items' (to fetch specific connections sequentially with rate-limit spacing) and when to omit it (to list across all linked banks). No ambiguity in 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?

The description adds significant behavioral context beyond the annotations: it explains CREDIT PENDING vs POSTED behavior varies by connector, details search_queries aggregation up to 5000, error handling (returns warning/error instead of throwing), and indicates connection health checks. No contradiction with annotations.

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

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

The description is long but well-structured, starting with the core purpose, then special credit card notes, filtering details, error handling, and bulk support. Every sentence adds value, though it could be slightly more concise without losing clarity.

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

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

Given the tool's complexity (7 parameters, no output schema, complex behavior), the description covers purpose, credit card specifics, search semantics, pagination limits, error handling, and connections to other tools. It lacks explicit output format details, but that is acceptable without an output schema.

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

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

The input schema has 0% description coverage, but the description fully compensates by explaining each parameter: from/to as ISO YYYY-MM-DD, page_size limit (max 500), search_queries with case- and accent-insensitive OR semantics, and account_ids for bulk execution. It also describes the behavior when search_queries is set.

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

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

The description clearly states the tool returns transactions for bank accounts (BANK or CREDIT), with a specific verb and resource. It distinguishes itself from siblings by noting that for CREDIT accounts, this is the only way to get itemized transactions, and it references openfinance_list_credit_card_bills for bill totals.

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

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

The description explicitly states when to use this tool vs alternatives: it is the only way for credit card itemized transactions, while openfinance_list_credit_card_bills should be used for standardized bill totals. It also advises checking openfinance_get_item_status if total is 0 for CREDIT accounts, and narrowing date range if truncated:true is returned.

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

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

Annotations provide readOnlyHint=true and destructiveHint=false. The description adds critical behaviors: internal account resolution, default granularity returns compact summary, raw returns full rows, and a scan cap of 5000 per account with truncation flag. No contradictions.

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

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

The description is a single well-structured paragraph that front-loads the core purpose and then details parameter usage. It is slightly long but 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 6 parameters, no output schema, and moderate complexity, the description covers all necessary aspects: purpose, usage, parameter constraints, behavioral limits (truncation), and examples. No gaps for agent decision-making.

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

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

Despite 0% schema description coverage, the description explains item, from/to (ISO dates), granularity ('monthly' vs 'raw'), type (BANK/CREDIT), and top_n (implied by 'largest N each'). All 6 parameters are given meaningful context beyond the schema.

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

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

The description clearly states it performs consolidated cash-flow analysis for a bank connection in one call, resolving accounts internally. It names the verb 'analyze' and resource 'connection transactions', and distinguishes from sibling tools like openfinance_list_accounts and 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 use cases ('análise anual/mensal', 'fluxo de caixa', 'entradas e saídas') and explains optional parameters ('item' for one bank or all). Lacks explicit when-not-to-use scenarios but gives alternatives via granularity settings.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds behavioral context: it checks a public status page, returns incidents affecting connected banks, and reveals upstream outages. No contradictions.

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

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

The description is a single, well-structured paragraph that front-loads the purpose and then provides usage guidance and return details. Every sentence adds value, 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?

Given zero parameters and no output schema, the description fully covers what the tool does, when to use it, and what it returns. It is complete and sufficient for an agent to select and invoke 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?

Input schema has zero parameters, so the baseline is 4. The description adds meaning beyond the schema by explaining the tool's purpose and output, even though no parameters exist.

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

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

The description clearly states it checks the live operational status of the Open Finance provider, distinguishes it from the sibling tool openfinance_get_item_status, and lists the specific return values (global indicator, degraded components, incidents, affected banks).

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

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

Explicitly tells when to use this tool: when data looks incomplete or stale despite an updated connection, to differentiate provider-side outages from connection issues. This provides clear decision guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds context: honors user's plan (PF plan hides PJ banks), returns a hint if keywords empty, and includes a connect_url. These details go beyond what annotations provide.

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

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

Two sentences cover functionality, outputs, usage context, and constraints. Every part is useful, no fluff, and 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?

Covers inputs, expected behavior (plan filtering, empty keywords), and output fields. Doesn't discuss pagination or error cases beyond the hint, but for a search tool with strong annotations, this 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?

Input schema has 0% description coverage, so the description must compensate. It explains 'keywords[]' with an example (['nubank','btg']) and states it's required (though schema marks optional). It also explains 'include_accounts' adds account details. The discrepancy on required is minor but slightly misleading.

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 searches bank connectors by name, lists the returned fields (connector id, access type, audience, linked connections, connect_url), and gives a usage directive: 'Call this BEFORE connecting to hand the user a one-click link to the right bank.' Distinguishes from siblings like 'authenticate' and 'connect' by specifying this is a search/pre-selection 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?

Explicitly tells when to use ('Call this BEFORE connecting') and what happens without keywords (returns a hint). Implies not to use it for dumping the whole catalog. Doesn't explicitly contrast with siblings like 'openfinance_list_connections' but the purpose is clear enough.

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

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

Annotations are minimal (readOnlyHint false, destructiveHint false, idempotentHint false). The description adds critical context: overriding automatic categorization, creating a Category Rule for future similar transactions, and per-item error handling. No contradiction with annotations.

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

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

The single paragraph is well-structured: endpoint first, parameter explanation, side effects, response shape. Every sentence serves a purpose; no filler or repetition. Efficient and front-loaded.

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

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

Despite no output schema, the description fully documents the response shape (`{ updated, results: [...], errors: [...] }`) and side effects. Parameter guidance, behavioral implications, and error handling are comprehensively covered. The agent has all necessary information to use the tool correctly.

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

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

Schema coverage is 0%, so description must compensate. It explains the two required fields (transaction_id, category_id) and their origins. While it does not elaborate on types (already in schema), it provides essential sourcing guidance, adding value beyond the schema.

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

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

The description clearly states the tool corrects transaction categories via PATCH /transactions/:id, with specific verbs and resource. It distinguishes itself from sibling tools (e.g., list, sync, force_sync) by focusing on mutation and category rule creation.

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 where to obtain parameters (transaction_id from openfinance_list_transactions, category_id from openfinance_list_categories) and recommends using it to fix miscategorized transactions. It implies when to use but does not explicitly state when not to use or mention alternatives, though context is sufficient.

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

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

Annotations indicate idempotent and non-destructive behavior. The description does not add further behavioral details (e.g., processing time, rate limits), but does not contradict annotations.

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

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

Two concise sentences provide essential information without extraneous 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?

For a simple feedback tool without output schema, the description covers primary usage. Could note that 'message' is required, but overall it is complete enough for correct invocation.

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

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

With 0% schema coverage, description partially compensates by explaining the conversation parameter. However, 'context' parameter remains unexplained, and no format details are given for the conversation string.

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

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

The description clearly states the tool's purpose: reporting bugs, missing features, or sending feedback. It is distinct from sibling tools, which focus on financial operations.

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

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

It instructs to include the conversation array for reproduction, providing clear context. No exclusions or alternatives are needed since no sibling tool serves the same function.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint. The description adds the specific output (MCP platform and adapter versions), which provides useful context beyond annotations.

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

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

The description is a single sentence, very concise, and front-loaded with the key action and resource. There is no wasted text.

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

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

The description fully explains what the tool returns (current MCP platform and adapter versions) and there are no parameters. This is complete for a simple version tool.

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

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

There are no parameters, and schema description coverage is 100%. The description adds no parameter information because none is needed.

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

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

The description clearly states the tool's purpose: showing current MCP platform and adapter versions. It uses a specific verb ('Show') and resource, and it is easily distinguishable 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?

No explicit guidance on when to use this tool vs. alternatives is provided. The context is implied—it's a simple version display—but there is no mention of when not to use it or of alternative tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds context on the specific output (installed MCPs, connection status, catalog tool counts). 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?

Single sentence that is front-loaded and concise. No superfluous information; every word 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?

Description adequately explains what the tool returns given no parameters and no output schema. Could potentially mention output format, but current description is sufficient for an AI agent to understand usage.

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 is 100% and description fully explains the tool's output. The description adds meaning beyond the schema by specifying what the returned state includes.

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 tool returns current toolkit state: installed MCPs, their connection status, and count of catalog tools each exposes. Differentiates from sibling tools which handle authentication, financial data, or reporting.

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

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

Description does not explicitly state when to use or not use this tool. However, its purpose as a status tool is implied, and annotations indicate it is safe and idempotent. No guidance on alternatives among siblings.

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