Player's Bank MCP

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

Annotations indicate readOnlyHint=false and idempotentHint=true. Description adds context about persistence (permanent vs session) and the token source (browser). No contradictions with annotations. Could mention error behavior or permission details but 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?

Description is relatively long but each sentence adds value. Front-loaded with main purpose. Could trim some redundancy (e.g., 'Best: add it...' is slightly conversational) but structure is logical.

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 authentication tool with one optional parameter and no output schema, the description covers both usage modes and token acquisition. It is complete enough for an agent to invoke correctly without 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?

Schema has only one optional string parameter with 0% described. Description fully compensates: explains token is a JWT, how to obtain it, and that omitting token returns a login link. Adds essential 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 specifies the tool's role: authentication for MCP.AI IDE agents. It distinguishes two login methods (permanent config vs session token) and the option to call without arguments to get a login link. This is specific and distinct from sibling tools like 'connect'.

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 when-to-use guidance: permanent token via config for non-expiring access, or session-only token by pasting JWT. Also explains calling with no args to get link. Does not explicitly list exclusions or when not to use, but context is sufficient for an agent to decide.

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. Description adds valuable context about return behavior (authenticated status and URLs), going 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 concise sentences with no waste, front-loaded with the main purpose immediately.

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 covers the two key return scenarios comprehensively, sufficient for an agent to understand behavior.

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

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

No parameters in schema, schema coverage is 100%. Description doesn't need to add parameter info; baseline for zero params 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?

Clearly states it returns connection status and URLs, differentiating from siblings like 'authenticate'. The two cases (all connected vs. missing credentials) are explained, providing a 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?

Implies usage for checking connection status, but no explicit guidance on when to use versus alternatives like 'authenticate'. No exclusions or alternative mentions.

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 reveals many behavioral details beyond annotations: invoke works even when the MCP isn't installed and runs it "without bloating the tool list"; credential needs return a connect link; empty wallet returns a checkout/top-up link; search/describe flag installation status; writes require workspace owner/admin. This greatly exceeds the sparse annotations (readOnlyHint false, openWorldHint true).

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 dense single paragraph, but it is front-loaded with the core purpose and flows. Every sentence contributes new information, including the key invoke behavior and the prompt library. It could benefit from bullet points to improve scannability, but its length is justified by 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?

The description covers primary workflows, permissions, billing, authentication links, and the prompt library, which is impressive for such a multifaceted tool. However, it omits the `resume` action, does not explain the `immediate` parameter, and provides no return format (there is no output schema). These gaps make it slightly incomplete.

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 23 parameters and 0% documentation coverage. The description explains the `action` parameter's values and implies the roles of `query`, `mcp_id`, and `tool_id`, but it does not explain `limit`, `arguments`, `immediate`, `tier_slug`, `prompt_vars`, or other parameters. Given the large parameter surface, the description compensates only minimally.

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 "the official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them." It enumerates specific actions (search, describe, invoke, install, subscribe, etc.), distinguishing this tool from sibling OpenFinance tools which focus on financial data.

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?

Usage guidance is explicit and actionable. It states the core flow (action=search → describe → invoke), explicitly contrasts invoke vs. install ("prefer invoke for a single/occasional use" and "Use install only to make an MCP PERMANENT"), and describes when list_tools, subscribe/cancel, report_bug, and request_mcp are appropriate. It also notes that writes require owner/admin.

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?

Adds behavioral details beyond destructiveHint: reveals data deletion, unavailability, and return of re-connect URL.

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 three-sentence description with no unnecessary words, front-loaded with key 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?

Adequately covers main action and outcome, but missing parameter description and response format beyond one line.

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 sole parameter 'item' is not explained in the description; schema coverage is 0%.

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 revokes consent and deletes connection data, making it distinct from sibling tools like connect or list 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?

Purpose is clear but lacks explicit guidance on when to use vs alternatives; no exclusion criteria.

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 fully discloses behavioral traits beyond annotations: it waits up to ~60s, polls until completion, returns specific fields (`status`, `executionStatus`, `lastUpdatedAt`, `synced`, `needs_action`), and handles special cases like `needs_action` with `reconnect_url`. No annotation contradiction (readOnlyHint=false, destructiveHint=false are consistent with a write operation).

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 detailed but well-structured and front-loaded with the core action. Every sentence adds value, though it could be slightly more concise. It efficiently combines multiple important details without being 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 (sync, polling, wait modes, error handling, reconnect flow), the description covers all essential aspects. It describes the return format despite lacking an output schema, and addresses sibling tools for follow-up. Complete for the 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%, but the description adds complete meaning beyond the schema. It explains that `items` accepts an array of selectors (item_id, connector_id, connector_name, custom_label nickname) and that omitting it syncs all. It also explains `wait`: false for fire-and-forget. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool forces a bank to re-sync connections, waits for completion, and returns results. It uses specific verbs ('forces', 're-sync', 'waits') and distinguishes from sibling tools like openfinance_get_item_status (mentioned for re-checking if timed out).

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 ('when a balance or transaction list looks stale') and what not to do ('WITHOUT disconnecting/reconnecting'). It provides alternatives: fire-and-forget mode with `wait: false`, and re-checking with openfinance_get_item_status for timed-out syncs.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds substantial behavioral context: the snapshot nature tied to last upstream sync, the meaning of updateDateTime/updatedAt, the difference between freshest available and live data, the specific error variants, and the degradation behavior with realtime: false and warnings. This goes well beyond the structured 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?

Although the description is lengthy, every sentence carries meaningful operational information: endpoint, freshness semantics, retry guidance, error cases, degradation behavior, and response shape. It is front-loaded with the core purpose and then expands into necessary edge cases without filler.

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

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

With no output schema, the description fully specifies the response shape and error structure. It also covers the main edge cases (credit consent errors, provider failures, stale sync, degraded rows) and how to recover. The description is complete for an agent to correctly invoke and interpret the result.

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 only defines account_ids as an array of strings, but the description adds crucial semantic constraints: the array must contain 1–50 account ids, and the parameter identifies which accounts to fetch balances for. This fully compensates for the 0% schema description 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 states a specific verb ('Returns'), a specific resource (balance per account id), and the exact endpoint (GET /accounts/:id/balance). It clearly distinguishes itself from sibling tools by noting how it relates to openfinance_list_transactions and openfinance_force_sync, making its 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 explicitly tells the agent when to use it, when the data may be stale, and when to switch to openfinance_force_sync. It also explains the conditions under which errors or degraded rows appear, giving clear operational guidance beyond just a bare definition.

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

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

The description adds significant behavioral context beyond annotations: it specifies that results come in a results/errors batch shape and may include a provider_incident block when the provider has an incident, warning that credit limits/balances may be unreliable. This alerts the agent to potential data quality issues, which annotations do not cover.

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 each sentence adds value. It could be slightly more concise by removing the example in parentheses, but overall it is efficient and well-structured.

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

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

Given the lack of an output schema, the description explains the batch shape and the provider_incident edge case, but does not elaborate on the full account object structure or the fields in creditData. For an agent to use the returned data, additional detail about the object schema would be helpful.

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

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

The single parameter account_ids is described as an array (1–50) and is required. The schema coverage is 0%, so the description fully compensates by specifying the array constraint and the batch nature. It does not explain the format of the strings, but the parameter name is self-explanatory.

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 mentions the batch shape. However, it does not explicitly distinguish from sibling tools like openfinance_list_accounts or openfinance_get_account_balance, though the mention of 'extended creditData' hints at greater detail.

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

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

No guidance is provided on when to use this tool versus alternatives. The description includes a caveat about provider incidents and a batch size constraint, but does not explain the appropriate context for selecting this tool over 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?

The description far exceeds the annotations by explaining behavioral nuances: `totalAmount` is authoritative and should not be reconstructed, `payments[]` typically reflects the previous bill rather than current-bill payment, Pluggy returns no paid/status field, and the opt-in transactions path triggers an extra full account scan. It also documents the three `transactions_basis` modes. These are material runtime behaviors the annotations alone do not convey.

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 and dense, but every sentence contributes critical operational detail such as opt-in costs, authoritative totals, fallback transaction-fetching, and payment-status caveats. It is front-loaded with the main purpose and returns, though the wall of text could have been better organized with bullets or section breaks.

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?

There is no output schema, so the description must define the response shape, and it does: result fields, transactions summary fields, `transactions_basis`, `transactions_window`, `transactions_hint`, and the `{results, errors}` batch envelope. It also gives enough context about Brazilian Open Finance and sibling tool alternatives for an agent to call this 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?

With schema description coverage at 0%, the description carries most of the parameter burden and succeeds for `bill_ids`, `account_id`, and `include_transactions`, including relationships among them. However, `transactions_detail` and its enum values (`compact`, `rich`, `raw`) are never explained, which is a notable gap for one of the four 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 opens with a specific verb and resource: 'Returns bill-level detail for one or more credit card bills by id (GET /bills/:id)' and enumerates concrete fields such as dueDate, billClosingDate, totalAmount, and payments[]. It also implicitly distinguishes itself from related bill-listing and transaction-listing tools by focusing on single-bill lookups by id.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: discover bill ids via openfinance_list_credit_card_bills first, prefer that sibling for derived paid status, and fetch transactions separately via openfinance_list_transactions if not opting in. It also clarifies when `transactions_basis` is exact versus estimated, giving agents clear decision prerequisites.

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, and destructiveHint false. The description adds important behavioral context: the reconnect_url reopens the widget in UPDATE mode for re-authentication without disconnecting or consuming a slot. It also describes the return format for single vs. all banks. No rate limits or data freshness are mentioned, but overall good transparency.

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, using two sentences and a line about bulk support. It is front-loaded with the core purpose. However, the first sentence is somewhat long and could be split for readability. No unnecessary words, but slight improvement in structure would earn a 5.

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 (3 optional parameters, no output schema, annotations present), the description covers return values, behavior differences, and reconnect functionality. It lacks explanation for `item_id` and does not mention authentication requirements or error scenarios. With siblings, it mostly stands alone but could better distinguish from openfinance_list_connections.

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

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

Schema coverage is 0%, so the description must explain all parameters. It explains `item` (single bank) and `item_ids` (bulk), but does not explain `item_id`. The relationship between `item` and `item_id` is unclear, leaving ambiguity. This is a significant gap given the lack of schema descriptions.

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

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

The description clearly states it returns the current status of a bank connection, listing possible statuses like UPDATED and LOGIN_ERROR, plus executionStatus, connector metadata, and reconnect_url. It distinguishes between single bank (using `item`) and all linked banks (omitting `item`), and mentions bulk support with `item_ids`. This specificity differentiates 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 context on when to use `item` versus omitting it, and mentions bulk support. However, it does not explicitly state when NOT to use this tool versus alternatives like openfinance_list_connections, which might return similar data. No explicit exclusions or alternative recommendations are given.

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

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

Annotations already declare readOnlyHint and idempotentHint; description adds return shape (batch with results/errors) but no further 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?

Single sentence front-loads purpose and lists fields; slightly verbose but efficient for the detail provided.

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

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

No output schema, but description enumerates returned fields and batch format; adequate for a detail retrieval tool, though error handling not addressed.

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; description adds constraint (array 1-50) and implicit ID meaning, compensating for schema gap.

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

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

Description clearly states returns full loan contract detail by ID, lists specific fields, and distinguishes from sibling tool 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 advises using after openfinance_list_loans for deep-dive, specifies array size 1-50 and batch shape, but does not discuss when 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?

Annotations already mark readOnlyHint=true, idempotentHint=true, destructiveHint=false, and the description does not contradict them. It adds substantial behavioral caveats: connector-dependent meaning of CREDIT `balance`, `balance_notice` meaning zero may not mean zero payable, stale `bankData` after first connection, `provider_incident` unreliability, and `identity_notice` dedupe rule. This far exceeds 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?

Long but front-loaded: the core return value is in the first sentence, and each subsequent paragraph adds a distinct caution an agent needs before presenting data. The structure (separate caveats for balance, bankData, provider_incident, identity_notice) makes the length navigable, though it is wordier than strictly necessary.

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

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

With no output schema, the description must explain both return contents and per-row semantics, and it does: field meanings, `bank` vs `name`, aggregation behavior when omitting `item`, and all notice blocks. It also ties into sibling tools for further actions. Nothing an agent needs to call this correctly or interpret its results is missing.

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

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

Schema coverage is 0%, so the description carries the load. It explains `item` vs omitting it, `item_ids` for bulk, and the BANK/CREDIT categories, but it never explicitly describes the singular `item_id` parameter or states that `type` is a filter. Still, it substantially compensates for the schema's lack of descriptions.

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

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

States a specific operation ('Returns accounts for a bank connection') and enumerates exactly what is returned for BANK and CREDIT rows, including derived fields. It clearly distinguishes from sibling openfinance_list_credit_card_bills by pointing to it for standardized bill amounts, so an agent can separate account listing from bill listing.

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 instructs when to omit `item` (list across ALL linked banks when user says 'my accounts/cards' without naming a bank) and when to pass `item` (target a single bank). It also names openfinance_list_credit_card_bills as the alternative for standardized open-bill amounts and openfinance_force_sync for reconciling lagging fields, giving concrete routing 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, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context: the response is cached, it is a single aggregated response (no batch ids), and explains the field structure. This exceeds what annotations alone provide.

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

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

The description is two sentences: the first states the core functionality and the second details the output fields. Every sentence adds value, and there is no superfluous information. It is front-loaded and efficient.

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

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

Despite having no output schema, the description fully describes each field in the response entries (id, description, descriptionTranslated, parentId, parentDescription) and notes caching and batch behavior. This is complete for a simple read-only taxonomy 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?

The input schema has no parameters, so schema description coverage is 100%. The baseline score is 4 per the rubric. The description adds no parameter information because none exist, but it does explain the returned fields, which is peripheral to parameter semantics.

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 tool's purpose is clearly stated: it returns Pluggy's transaction category taxonomy. It specifies the HTTP method (GET /categories), caching behavior, and explicitly links to the sibling tool that uses the categoryId. This differentiates it from other list or update tools.

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

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

The description implies usage context by noting the id is used by openfinance_update_transaction_category and that the response is cached for the session. However, it does not explicitly state when to use this tool versus alternatives or provide exclusionary criteria.

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 readOnlyHint=true, but the description adds behavioral context: the reconnect_url behavior (opens UPDATE mode, refreshes in place) and that it does not consume a slot or require disconnecting. No contradiction with annotations.

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

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

The description is relatively concise but contains necessary details about both the main output and the reconnect_url behavior. It front-loads the main purpose and then adds usage notes, keeping it efficient without unnecessary verbiage.

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, no output schema, and low complexity, the description fully covers what the tool returns and how to use the reconnect_url. No gaps remain for the agent to need additional information.

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 no parameters, so schema coverage is 100%. With zero parameters, baseline is 4. The description adds value by explaining what the tool returns, compensating for the lack of output schema.

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

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

The description clearly states the tool returns saved bank connections with specific fields (connector_id, item_id, bank name, etc.), distinguishing it from siblings like openfinance_list_accounts or openfinance_disconnect_bank. The verb 'Returns' and the list of fields define the function precisely.

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

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

The description provides explicit guidance on when to use the reconnect_url (needs re-authentication, MFA errors, stale data) and states it does not consume a slot or require disconnecting. However, it does not contrast this list tool with other list siblings (e.g., openfinance_list_transactions) for general listing scenarios.

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

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

The description exhaustively details payment semantics, derived payment_status, billing cycles, connector asymmetry, and warnings about bill grouping reliability. This goes far beyond the annotations (readOnly, idempotent, not 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 overly long and dense, mixing semantic explanations, usage guidelines, and parameter details without clear separation. It could be more structured and concise, as many sentences add significant detail but reduce readability.

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

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

Despite missing page/page_size, the description covers almost all relevant context: edge cases, derived fields, connector limitations, and warnings. It is highly complete given the tool's complexity and lack of 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 description explains account_id, account_ids, and include_open_bill in depth, but misses page and page_size. With 0% schema coverage, the description should cover all parameters; it misses two, leaving them ambiguous.

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 closed credit card bills for CREDIT-type accounts, lists key fields, and distinguishes itself from sibling tools like openfinance_get_credit_card_bill and openfinance_list_transactions. It also mentions bulk support via account_ids.

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

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

The description provides explicit guidance on when to use this tool vs alternatives, such as directing to openfinance_list_transactions for itemized transactions. It also explains the opt-in nature of include_open_bill and warns against reconstructing totals.

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

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

The description adds significant behavioral context beyond annotations: graceful error handling (returns warning instead of throwing on 403), data integrity cross-checking for mass zeroing, and flagging suspect positions with integrity:'suspect_zeroed'. Annotations already declare readOnlyHint=true, and description confirms no destructive actions.

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 but becomes verbose with detailed data integrity warnings. It could be more concise while retaining key information.

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

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

Given no output schema and 6 parameters with 0% schema coverage, the description covers the return format, error handling, and data integrity well. However, it lacks descriptions for individual parameters, which is a gap for completeness.

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

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

Schema description coverage is 0%, but the description only adds meaning for one parameter (item_ids for bulk support). Other parameters like item, page, type, page_size are not described. The enum values in schema are not explained in the description.

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 investment portfolio for a connection, listing specific investment types (FIIs, stocks, ETFs, etc.) with detailed fields. It distinguishes from siblings like openfinance_list_investment_transactions by focusing on portfolio overview.

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

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

The description implies usage for retrieving investment portfolios but does not explicitly guide when to use this tool versus alternatives like openfinance_list_investment_transactions or openfinance_get_account_balance. No exclusions or criteria are provided.

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 behavioral details: lists transaction types, returned fields (quantity, value, amount, netAmount, expenses), and bulk support. 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 concise paragraphs, front-loaded with purpose and key details. No fluff. Efficiently covers purpose, fields, prerequisite, and bulk mode.

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?

Output schema absent, but description enumerates many return fields and provides prerequisite. Missing pagination behavior and error handling. Adequate for a read-only list tool with good 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?

With 0% schema description coverage, description must compensate. Only investment_id and investment_ids are described; page and page_size are omitted entirely, leaving the agent unaware of pagination support.

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 movement history for investment positions (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER). It distinguishes from siblings by specifying investment-specific transactions and referencing openfinance_list_investments as a prerequisite.

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: use after openfinance_list_investments to get investment_id. Mentions bulk support with investment_ids. Does not explicitly contrast with openfinance_list_transactions or state when not to use.

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?

Adds significant behavioral details beyond annotations: per-connection result format, sequential querying with rate limiting, and that omitting 'items' queries all connections. Annotations already indicate read-only and idempotent.

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. Uses backticks for parameter names. 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 no output schema, the description mentions return shape '{ results, errors }' per connection. Covers multiple connections, rate limiting, and connection selectors. Complete for a list operation.

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

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

Schema has 0% description coverage, but the description fully explains the 'items' parameter: its purpose, acceptable formats (item_id uuid, connector_id, connector_name), and the behavior of omitting it.

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' with the HTTP method. It is specific about the resource and distinguishes from siblings like openfinance_get_loan_detail.

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

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

Describes when to include 'items' (fetch specific connections) and when to omit (all banks), and mentions sequential querying with rate-limit spacing. Does not explicitly state when not to use compared to siblings but provides solid context.

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

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

Annotations provide readOnlyHint/idempotentHint/destructiveHint, but the description adds substantial non-obvious behavior: auto-pagination up to a 5000 ceiling with `truncated:true`, the non-throwing { total:0, results:[], warning, error } error envelope, scheduled future-dated rows ordered to the top with `scheduled:true`, per-connector PENDING/POSTED variance, `provider_incident` behavior ('reconnecting does not fix it'), and detail-mode costs. These are exactly the behavioral surprises an agent cannot infer from annotations or schema.

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?

Clearly structured with labeled sections (PAGINATION, SCHEDULED ROWS, detail) and front-loaded warnings in caps. It is, however, very long and contains redundancy: the do-NOT-sum-by-billId warning and Nubank sparsity note appear twice almost verbatim (once in the main body, once under `detail:'rich'`). That duplication plus the overall bulk prevents a top score, but every other sentence earns its place for a tool with this many edge cases.

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

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

No output schema exists, so the description carries the full burden of explaining return content — and it does: the opening `account` echo block, `scheduled_count`/`notice`, `truncated` behavior, real vs logical `total`/`totalPages`, error envelope, `provider_incident` block, and credit-health-check path when total is 0. An agent has everything needed to call the tool, interpret results, and decide on fallback tools.

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 full burden — and it pays: `from`/`to` get ISO format plus the 'to=today means confirmed-only' semantic; `search_queries` gets accent/case-insensitive OR-substring matching and the 5000-row pre-filter aggregation; `page`/`page_size` get dual auto-vs-manual semantics with defaults/max; `detail` gets compact/rich/raw meaning; `account_ids` gets bulk support; `account_id` gets the echo cross-check guidance. Every one of the 8 parameters gains meaning beyond its schema name.

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?

Opens with a specific verb + resource: 'Returns transactions for a bank account (BANK or CREDIT type).' It immediately distinguishes itself from siblings: 'this is the ONLY way to get itemized transactions' for CREDIT accounts, and repeatedly draws boundaries against openfinance_list_credit_card_bills and openfinance_list_transactions_by_item. An agent knows exactly what this tool is for and what it is not.

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

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

Explicit alternatives are given with conditions: use openfinance_list_credit_card_bills for open-bill total / total_pending_debt, use openfinance_list_accounts for closing/due dates, and use openfinance_get_item_status when total is 0 for a CREDIT account. It also says when not to sum by billId, how to restrict to confirmed transactions (to = today), and when to switch from auto to manual pagination. No inference is left to the agent.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description discloses important behaviors: truncation at 5000/account, provider_incident block indicating incomplete data, and that reconnecting does not fix provider issues. These add significant context for the agent.

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, with the main benefit front-loaded, followed by parameter explanations, use cases, and caveats. Every sentence adds value, though minor trimming could improve conciseness.

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

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

Given the complexity (9 parameters, no output schema, many siblings), the description is remarkably complete. It explains the compact return format (por_mes, top_despesas, etc.), the raw format, truncation limits, and provider incidents. It also covers bulk support via item_ids.

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

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

Although the schema has 9 parameters with 0% description coverage in the schema, the tool description compensates thoroughly. It explains the meaning of item (supports multiple identifier types), from/to (ISO dates), granularity (monthly vs raw), detail (compact, rich, raw), type (BANK/CREDIT), and item_ids for bulk. This adds much-needed semantics beyond the schema.

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

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

The description clearly states the tool's purpose: consolidated cash-flow analysis for a whole bank connection in one call. It specifies the verb 'analyze' and resource 'connection transactions', and distinguishes itself from the need to call openfinance_list_accounts separately.

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

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

The description provides explicit guidance on when to use this tool (e.g., for annual/monthly analysis, cash flow, top expenses), and when to omit parameters (item for all banks, granularity for raw data). However, it does not directly differentiate from similar siblings like openfinance_list_transactions, though it implies a consolidated approach.

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; description adds that it is a live check and details the returned information.

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 is comprehensive but somewhat lengthy; however it front-loads the purpose and efficiently covers usage.

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, description fully covers return fields and provides enough context for the tool's operation.

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

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

No parameters in schema, so description doesn't need to explain them; baseline 4 for 0 params.

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

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

Clearly states it checks the LIVE operational status of the Open Finance provider, distinguishing it from the sibling openfinance_get_item_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 specifies when to use (when data is incomplete/stale despite updated connection) and contrasts with the sibling 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 declare readOnlyHint, idempotentHint, destructiveHint. The description adds valuable behavioral details: it honors user's plan (PF hides PJ banks), returns ready connect_url, and surfaces caveat warnings for non-Open-Finance connectors. It also explains that keywords[] is required and that it never dumps the whole catalog. These details go 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, well-structured paragraph that packs essential information without being verbose. It is front-loaded with the main action and gradually adds details. A bullet-point structure could improve scannability, but it remains concise 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?

Given the complexity (search with plan behavior, caveats, connect_url, return fields) and no output schema, the description covers all necessary aspects: return values, plan rules, caveat handling, and recommended usage. It leaves no major gaps for an AI agent to misuse 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?

Schema coverage is 0%, so description must compensate. It explains 'keywords[]' with examples (e.g., ['nubank','btg']) and states it's required. It explains 'include_accounts' triggers returning accounts. This adds meaningful semantics 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 it searches bank connectors by name, returns connector id, access type, audience, linked connections, accounts, and a ready connect_url. It distinguishes itself as a pre-connect search tool, contrasting with sibling tools like 'connect' or 'marketplace'. The specific verb 'search' and resource 'bank connectors' make 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 explicitly tells when to use the tool ('Call this BEFORE connecting') and explains the behavior without keywords (returns hint, never dumps catalog). It also advises preferring Open Finance connectors due to caveats on credential connectors. However, it does not directly compare to sibling tools like 'openfinance_list_connections' or 'marketplace', missing some alternative 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?

Description discloses that recategorizing creates a Category Rule affecting future transactions, batch error handling (per-item errors do not fail whole batch), and return shape. Annotations only provide readOnlyHint, etc., so description adds substantial behavioral context.

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

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

Description is detailed but concise given the complexity, with front-loaded purpose and logical flow from usage to side effects to batch behavior. Every sentence adds value, though could be slightly trimmed.

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 1 parameter, no output schema, and sparse annotations, the description covers purpose, parameter semantics, side effects, error handling, and return format thoroughly, enabling correct tool use.

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

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

Schema has 0% description coverage for items. Description explains items is an array of {transaction_id, category_id}, clarifies ID origins, and describes batch response shape. This compensates for missing schema descriptions.

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

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

Description clearly states the tool corrects transaction categories via PATCH /transactions/:id, and distinguishes it from sibling tools by referencing openfinance_list_transactions and openfinance_list_categories for ID sources.

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 this to fix miscategorized transactions and improve categorization accuracy going forward.' Describes side effect of creating Category Rules but does not explicitly state 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?

Annotations already indicate idempotentHint=true and destructiveHint=false, so the agent knows the tool is safe and non-destructive. The description adds no extra behavioral traits such as authentication requirements or side effects, 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?

The description is two sentences: first states purpose, second gives a key usage hint. It is concise, front-loaded, and every sentence adds value with no unnecessary words.

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

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

Given the tool has 3 parameters (1 required) and no output schema, the description covers the purpose but omits details on parameter semantics for 'message' and 'context'. It also fails to describe what happens after reporting (e.g., ticket creation), leaving the agent with incomplete information.

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

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

With 0% schema description coverage, the description must compensate. It only explains the 'conversation' parameter ('Include the conversation array with recent messages for reproduction'), leaving 'message' and 'context' unexplained. The required 'message' parameter lacks any guidance on format or content.

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's purpose: 'Report a bug, missing feature, or send feedback.' This clearly identifies the verb and resource, and it distinguishes from sibling tools which are primarily finance-related.

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

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

The description provides clear context for use: report bugs/feedback. It advises including the conversation array for reproduction. However, it does not explicitly state when not to use or mention 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, destructiveHint, and idempotentHint. The description adds no additional behavioral context beyond what annotations provide, which is acceptable for a simple read-only operation.

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, concise sentence that directly conveys the tool's function with no extraneous information.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is fully complete for an agent to understand and invoke 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?

The tool has no parameters, and schema description coverage is 100%. For zero parameters, the baseline score is 4, as no additional parameter information is needed.

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

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

The description clearly states the tool shows MCP platform and adapter versions, using a specific verb and resource. It distinguishes from sibling tools like authenticate and connect, 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 retrieving version info, but does not explicitly state when to use or provide alternatives. Given the tool's simplicity, the implied usage is adequate.

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, and non-destructive behavior. The description adds valuable detail about the exact content returned, such as installed MCPs and connection status, without contradicting annotations.

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

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

The description is a single, well-structured sentence that front-loads the primary action ('Returns the current toolkit state') and then lists the specific data included. 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 zero-parameter, read-only tool with no output schema, the description thoroughly covers what the tool does and what it returns. The four data components listed provide a complete picture of the return value.

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

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

The tool has zero parameters, so the baseline is 4. The description doesn't need to explain parameters, and the schema coverage is effectively complete.

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

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

The description clearly states the tool returns the current toolkit state, listing specific components (installed MCPs, connection status, accounts, catalog tool counts). This distinguishes it from sibling tools that operate on financial data or 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 context is clear: this is a read-only informational tool for inspecting toolkit status. It does not explicitly mention when not to use it or name alternatives, but the unique purpose is evident from the description.

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