Pague Veloz Serasa MCP

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

Annotations indicate idempotentHint=true, destructiveHint=false. Description matches by describing token-based login without destructive effects. No contradiction, but could elaborate on repeated call behavior.

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 informative but slightly verbose. Could be structured into clearer sections (setup vs runtime), but each 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?

Covers both authentication flows, setup advice, and parameter usage. No output schema needed for action tool. Complete for the tool's complexity.

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?

0% schema coverage, but description fully explains the 'token' parameter: optional, JWT from browser login, and no-args returns link. Adds significant meaning beyond bare schema type.

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

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

Description clearly states the tool is for authentication via browser token or token input. Distinguished from sibling tools like 'connect' and 'openfinance_*' which are unrelated.

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

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

Explicitly explains two usage methods: permanent via config or session via token argument. Implies when not to use (e.g., already authenticated), but could be more explicit about 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=true, destructiveHint=false, idempotentHint=true. The description adds useful context about return values (authenticated, pending, connect_urls) and behavior when credentials are missing, surpassing 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 fluff. First sentence states the main function, second details key scenarios. Every word 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?

The description covers two main states but lacks detail on potential partial connection states or other fields like a general 'status' field. As there is no output schema, more completeness would be beneficial.

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, so schema coverage is 100%. The description adds value by explaining the return behavior, which is beyond parameter documentation. Baseline 4 applies for zero-parameter tools.

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 connection status and URLs, with specific scenarios. It differentiates from sibling tools like 'authenticate' by focusing on status rather than performing authentication, but does not explicitly name alternatives.

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

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

The description implies usage for checking connection status by describing two states, but does not explicitly state when to use this tool versus alternatives like 'openfinance_provider_status' or 'authenticate'.

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

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

The description goes well beyond the sparse annotations. It discloses key behavioral traits: invoke runs tools even when not installed, does not bloat the tool list, returns a connect link for missing credentials, and returns a top-up link for empty wallets. It also states permission requirements for writes, adding critical state-change context that the annotations (readOnlyHint=false, openWorldHint=true) do not detail.

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

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

The description is lengthy but well-structured: definition, core flow, key invocation behavior, permission notes, and prompt library section. Each sentence contributes necessary information for a tool with 14 distinct actions. A few minor redundancies (e.g., 'pontualmente' and re-emphasis) could be trimmed, but overall it is appropriately detailed for the 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?

Given no output schema and only four boolean annotations, the description covers the main flows (search/describe/invoke), the install-vs-invoke trade-off, auth/payment outcomes, permissions, and the prompt library. It omits details on 'resume' and some parameter-specific nuances, but for a tool of this breadth, it provides sufficient orientation for an agent to select and invoke correctly in most scenarios.

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 must compensate for 23 parameters. It explains the 'action' parameter values and the overall flow, and indirectly covers prompt-related parameters via search_prompts/get_prompt/publish_prompt. However, many parameters like 'immediate', 'tier_slug', 'arguments', 'conversation', and 'message' are not described, leaving gaps for advanced or non-obvious options.

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 — the in-platform catalog of every MCP/tool, AND the way to run them,' and outlines the core flow (search → describe → invoke). It distinguishes itself from sibling tools (like openfinance_* data access tools) by focusing on MCP discovery and execution, making the purpose specific and unambiguous.

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

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

The description explicitly instructs when to use each action: 'Use install only to make an MCP PERMANENT in the active toolkit... prefer invoke for a single/occasional use.' It also covers when to use list_tools, subscribe/cancel, request_mcp, and the prompt library operations. This provides clear context and exclusions, such as noting 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?

Beyond the destructiveHint annotation, the description adds that data is permanently removed and provides the return value (add_connection_url), enhancing transparency about the tool's irreversible effect.

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 concise sentences: action, consequence, return value. No filler. Each sentence adds essential information.

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

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

The description covers purpose, effect, and outcome, but lacks clarity on the required input parameter. Given no output schema, it partially compensates by mentioning the return URL, but the missing parameter definition reduces 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?

With 0% schema description coverage, the description must explain the 'item' parameter. It only says 'specific bank' but does not clarify whether 'item' is a bank ID, name, or other identifier, leaving ambiguity.

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 action ('Revokes consent and deletes connection data') and the target resource (specific bank). It distinguishes from siblings like 'connect' and other openfinance tools that deal with accounts, transactions, etc.

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 explains the consequence ('data will no longer be available') and mentions the return URL for re-connection, giving clear context on when to use. However, it does not explicitly state when not to use or list 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?

Discloses polling up to 60s, return fields, error states (needs_action with reconnect_url), and non-destructive nature. Annotations are minimal, so description carries burden. Lacks rate limit or side-effect 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?

Single paragraph, dense but readable. Front-loads action and mechanism. Could be slightly more scannable with structuring, but no wasted sentences.

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

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

No output schema, yet description fully explains return object (status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, timed_out) and how to handle each case. References sibling tool for re-check.

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?

Provides meaning beyond schema: items as array of selectors (optional), wait as toggle for synchronous vs fire-and-forget. Schema has 0% description coverage, so description compensates well.

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 the action ('forces re-sync'), the resource ('bank connections'), and the mechanism (PATCH + poll). Distinguishes from siblings like 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 states when to use (stale data), what not to do (no disconnect), alternatives (openfinance_get_item_status for timed_out), and both modes (sync all vs specific items, wait:false for fire-and-forget).

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?

Even though annotations already mark this as read-only and idempotent, the description adds substantial behavioral detail: balances are sync-anchored snapshots, `updatedAt` is the sync instant rather than live time, certain errors degrade to warnings with `realtime: false`, and specific Pluggy error codes are disclosed. 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?

The description is dense but every sentence earns its place: purpose, endpoint, snapshot caveat, remediation path, parameter format, error modes, degradation behavior, and response envelope are all covered without fluff. It is front-loaded by stating what the tool returns before diving into 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?

For a tool with no output schema, the description is remarkably complete: it gives the response shape, error row structure, degraded-mode fields, and the explicit instruction to force-sync before re-reading. An agent has enough information to invoke it correctly and interpret the result without further schemas or external knowledge.

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

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

Schema coverage is 0%, but the description fully compensates for the single `account_ids` parameter by specifying that it must be an array of 1–50 account IDs. It also ties the parameter to behavior, noting per-account rows and CREDIT-account error modes. The description carries the entire semantic burden and does so effectively.

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

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

The description opens with a specific verb and resource: 'Returns the latest available balance per account id' and names the endpoint. It is immediately distinct from sibling tools like openfinance_list_transactions and openfinance_get_accounts_detail because it focuses solely on balance retrieval, with no ambiguity about what it returns.

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 operational context: it explains the snapshot nature of the data, when staleness can occur, and explicitly instructs to call openfinance_force_sync and then re-read when the balance seems stale or disagrees with transactions. It doesn't explicitly contrast itself with every potentially overlapping sibling, but the primary usage condition 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 readOnly and idempotent behavior. The description adds critical context about batch shape, provider_incident blocks, and warnings about unreliable credit limits/balances. This significantly enhances transparency beyond structured fields.

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

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

Description is concise (4 sentences) with front-loaded main action. Every sentence adds essential value: purpose, parameter usage, batch shape, and critical caveat about data reliability. No redundancy.

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

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

For a single-parameter tool without output schema, the description covers purpose, parameter usage, batch response shape, and an important behavioral edge case. It does not detail the full return structure but provides sufficient context for proper 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?

Schema has one parameter with no description. The description adds the constraint 'array (1–50)' and hints at usage by passing account IDs. This compensates for the 0% schema coverage, though it doesn't specify ID format or item types.

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

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

The description clearly states the tool returns full account objects including extended creditData per ID, specifying the HTTP endpoint. It implies detail retrieval distinguishing it from listing tools, though sibling names are not explicitly mentioned.

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

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

The description advises to pass account_ids array (1-50) and warns about provider incidents affecting data reliability. It implies usage for detailed account data but does not explicitly instruct when to use this versus siblings like openfinance_get_account_balance.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint = false-safe GET, and the description adds substantial behavioral context beyond them: the three transactions_basis states, 'totalAmount is authoritative — do NOT roll back to summing transactions', the payments[] caveat (payments reflect the PREVIOUS bill cycle, not a paid flag from this bill), the cost of the transactions opt-in (extra full transaction scan), and the Pluggy no-paid-field note. These are exactly the traps that cause invocers to misinterpret results. 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 first sentence states the core purpose and return shape, and every subsequent sentence targets a real decision or irritate (discovery step, estimate-state, correctness warning, paid-status myth). None of the ~180 words are filler; each maps to something that would otherwise cause a wrong call or a misinterpreted result.

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 present, the description carries the return-format burden and it covers payments/transactions arrays and the batch shape plus batch semantics. It names the exact endpoint, repeatable idempotent semantics, the relevant siblings, and the paid caveates. The only genuine gap is the under-documented transactions_detail enum and edge behaviors (e.g., error when an id not found) — but given the batch shape, these are deemable minor.

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. It explains bill_ids (array, why it's required), account_id('bill itself carries no account reference'), and include_transactions (opt-in semantics, basis behavior, cost). However, transactions_detail (enum compact/rich/raw) is never mentioned in the description or schema, leaving an agent without any basis to pick an enum value. 3 out of 4 params are richly documented; one is fully opaque, hence 4.

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

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

The description opens with a specific verb+resource scope: 'Returns bill-level detail for one or more credit card bills by id (GET /bills/:id)', immediately distinguishing it from the sibling that lists bills (openfinance_list_credit_card_bills) and the one that lists account transactions (openfinance_list_transactions). It enumerates concrete returned fields, so an agent can tell exactly what this tool produces.

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 sequencing ('use openfinance_list_credit_card_bills first to discover ids'), an explicit alternative for fetching transactions (openfinance_list_transactions with from/to range ending at billClosingDate), and an explicit routing preference ('To check paid status, prefer openfinance_list_credit_card_bills'). It also states when the opt-in transactions mode is unavailable (open or untagged bills use date_window).

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context: the reconnect_url reopens the widget in UPDATE mode without disconnecting or consuming a connection slot, useful for re-authentication. This goes beyond what annotations provide.

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

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

The description is front-loaded with the main purpose and then adds structured details. Every sentence adds value, though it could be slightly condensed. Overall, it balances completeness and brevity well.

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 partly describes the return format (e.g., '{ count, items }' for bulk). It mentions key fields like status, executionStatus, connector metadata, and reconnect_url. It does not cover error handling or authentication, but it is sufficient for basic 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?

Schema has 3 parameters with 0% description coverage. The description explains that 'item' filters to a single bank, omitting it returns all, and 'item_ids' enables bulk execution. It clarifies the intent of each parameter, though 'item_id' vs 'item' is not explicitly distinguished.

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 bank connection status (UPDATED, UPDATING, etc.) and includes details like executionStatus, connector metadata, and reconnect_url. It distinguishes between returning all connections or a single one by omitting or providing the 'item' parameter, differentiating it from sibling tools like openfinance_list_connections.

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

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

The description explicitly explains when to omit 'item' (for all connections) versus providing it (for a single bank), and mentions bulk support via 'item_ids'. It does not, however, directly contrast with alternatives like force_sync or disconnect, but the usage scenarios are clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety profile is clear. Description adds batch response shape `{ results, errors }`, which is valuable behavioral context beyond annotations.

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

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

Single paragraph but well-organized: purpose, field list, usage hint, parameter instruction. No unnecessary words; 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?

With no output schema, description lists many return fields and batch shape, making return format clear. Provides usage sequence. Missing explicit note on ID validity and error handling, but adequate for the complexity.

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% so description compensates by stating 'Pass loan_ids as an array (1-50)'. Adds format and cardinality constraints beyond the schema. Could specify that IDs come from list_loans, but sufficient.

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

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

Clearly states it returns full loan contract detail by ID, lists specific fields (interestRates, installments, etc.). Distinguished from sibling openfinance_list_loans by explicit usage hint.

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

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

Explicitly says 'Use after openfinance_list_loans to deep-dive on a specific contract,' providing context. Also specifies array size limit (1-50). Does not mention when not to use or alternative tools, but context is strong.

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

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

The annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial behavioral context beyond that: connector-dependent credit balance meaning, balance_notice semantics, stale bankData fields, provider_incident unreliability, and identity_notice/dedupe rules. These warnings directly prevent incorrect user-facing statements and are not visible from annotations alone.

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

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

The description is long but every paragraph earns its place: core return value first, then operational caveats, then bulk support. The caveats are labeled and structured, making the length appropriate for the tool's complexity rather than redundant 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?

For a read-only listing tool with four optional parameters, no output schema, and many edge-case data-quality issues, the description covers return fields, filtering behavior, sibling routing, bulk execution, and warning blocks. It is sufficiently complete for an agent to invoke it correctly and interpret results safely.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters. It explains `item` (single bank vs all banks) and `item_ids` (bulk execution), and mentions `item_id` as a row tag, but it never explicitly states that the `type` parameter is a filter to BANK or CREDIT, nor does it clarify the relationship between `item` and `item_id` as input parameters. This leaves a real gap for a zero-coverage 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?

States a concrete read operation: returns bank/credit accounts with specific fields (balance, number, type, subtype, bankData, creditData, bank, connector_id). It also clarifies the difference between listing across all linked banks vs a single bank, which distinguishes it from sibling tools like openfinance_get_accounts_detail and openfinance_list_credit_card_bills.

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

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

Explicitly says when to omit `item` (user asks for 'my accounts/cards' without naming a bank) and when to pass `item` (target a single bank). It also routes the agent to openfinance_list_credit_card_bills for standardized bill amounts and openfinance_force_sync for stale fields, giving clear alternatives and when-not-to-use 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, idempotentHint, and destructiveHint. The description adds value by stating caching behavior, single aggregated response, and no batch ids, which goes beyond annotations.

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

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

The description is three sentences, front-loaded with the main purpose, and adds concise details without 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?

Despite having no output schema, the description fully details the response structure (id, description, descriptionTranslated, parentId, parentDescription), making it complete for the agent.

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

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

No parameters exist, so baseline 4 applies. The description does not need to add parameter info and correctly omits 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 it returns Pluggy's transaction category taxonomy, specifying it's cached and details the response fields. It distinguishes from sibling tools that list other entities like transactions or accounts.

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

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

The description indicates when to use (to get categories) and highlights the id's role in updating categories via another tool. It lacks explicit when-not-to-use, but the context is clear given no overlapping siblings.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: reconnect_url reopens the widget in UPDATE mode, does not require disconnecting, and does not consume a connection slot. 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 informative but somewhat lengthy. It front-loads the core purpose and then details the reconnect_url behavior. Could be slightly more concise but still 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?

Despite no output schema, the description enumerates all returned fields (connector_id, item_id, bank name, reconnect_url, add_connection_url) and explains the behavior of reconnect_url. For a simple list tool, this is 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?

No parameters exist, so baseline is 4. The description does not need to add parameter info. Schema coverage is trivially 100%.

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, reconnect_url, add_connection_url). It distinguishes from sibling tools like openfinance_list_accounts by focusing on connections rather than accounts or transactions.

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

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

The description explains when to use reconnect_url (for re-authentication, MFA, LOGIN_ERROR, stale data) and notes it does not consume a connection slot or require disconnecting. It implies not to use for new connections (use add_connection_url). However, it does not explicitly contrast with other sibling 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?

Discloses derived payment_status logic, payment cycle semantics, open_bill fallback/reasons, connector asymmetry, warning behavior, and bill-grouping issues. Adds substantial behavioral context beyond readOnlyHint and idempotentHint annotations. No contradiction.

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

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

First sentence fronts the core purpose, but the description is very long and dense, lacking structure (paragraphs, bullets). Every sentence adds value, but overall it is not concise; an AI agent may find it hard to parse quickly.

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 (open finance semantics, derived fields, connector asymmetry) and no output schema, the description covers all critical aspects: output fields, payment_status derivation, open_bill behavior, warnings, echo block. Complete for the tool's domain.

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

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

Schema coverage is 0%, so description carries burden. Thoroughly explains include_open_bill and account_ids, but lacks any description for page, page_size, or account_id (though account_id is implicit). Partially compensates but leaves standard pagination parameters unexplained.

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

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

Clearly states: 'Returns CLOSED credit card bills for a CREDIT-type account' and lists specific fields. Differentiates from sibling tools like openfinance_get_credit_card_bill (single bill) and openfinance_list_transactions (itemized purchases).

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 contrasts with openfinance_list_transactions for itemized purchases, advises against reconstructing totals, explains when to use open_bill vs balance, and warns about connector asymmetry. Provides clear when-to-use and when-not-to-use 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?

Beyond annotations (readOnlyHint, idempotentHint), the description adds critical behavioral details: error handling returns empty instead of throwing 403, and a detailed data integrity mechanism for mass zeroing with suspect_zeroed flags. This significantly enriches agent understanding.

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 verbose and includes a lengthy data integrity section that, while important, could be condensed. It front-loads the purpose but becomes dense. Some redundancy exists (e.g., listing fields again).

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

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

Given no output schema, the description adequately covers return structure (total, results, warning) and the special data_integrity_warning. It explains the main fields returned. However, it could better describe pagination behavior and the 'item' 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?

With 0% schema description coverage, the description should explain parameters. While it implies item_id/item_ids for connections, and type for filtering, it fails to define the 'item' and 'page'/'page_size' parameters clearly. This leaves ambiguity for an AI 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 investment portfolios for a connection, listing specific asset types (FIIs, stocks, ETFs, etc.) and detailed fields. It distinguishes itself from sibling tools like openfinance_list_investment_transactions by focusing on portfolio positions rather than transactions.

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

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

The description provides clear context for when to use this tool (for investment portfolio data) and mentions bulk support via item_ids. However, it does not explicitly exclude cases or compare with other tools like openfinance_list_accounts, though the scope is well-defined.

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. The description adds rich behavioral context: lists the types of transactions returned, the fields per row (quantity, value, etc.), and the dependency on another tool. No contradictions.

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

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

The description is concise, with two short paragraphs. The first states what the tool returns, the second gives a usage hint. No redundant phrases, front-loaded with key facts.

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 4 parameters, no output schema, and safety annotations, the description provides adequate context: core functionality, return fields, dependency on another tool, and bulk support. Missing explicit pagination documentation, but overall complete for the 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?

Schema description coverage is 0%. The description explains the use of investment_id and investment_ids (bulk support) but does not mention page and page_size, leaving those as common but undocumented pagination parameters. Partial compensation for required 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?

The description clearly states the tool returns movement history for a specific investment position, listing transaction types (BUY, SELL, TAX, etc.). It distinguishes from siblings by mentioning dependency on openfinance_list_investments for the investment_id and implying it's for detailed investment transactions, not 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?

The description provides clear context: 'Use after openfinance_list_investments to get the investment_id.' and bulk support hint. However, it does not explicitly state when not to use this tool vs alternatives like openfinance_list_transactions, though the context implies investment-specific usage.

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

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

Annotations already declare safe read-only behavior. Description adds valuable behavioral details: sequential querying with rate-limit spacing, per-connection {results, errors} response. 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?

Three concise sentences with front-loaded purpose, then parameter behavior, then output structure. Every sentence earns its place. 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?

Covers main use cases (with/without items), response structure, and rate-limit behavior. No output schema, but description gives basic response shape. Could mention pagination or limits, but overall complete for a 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?

Schema has 0% description coverage for the single parameter 'items'. Description fully compensates by explaining items are connection selectors (uuid, id, name) and that each entry fetches one connection. Adds meaning beyond 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?

Description clearly states it lists loan contracts per bank connection with GET endpoint. Distinguishes from sibling get_loan_detail by specifying per-connection listing and optional filtering. Verb+resource+scope all 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?

Provides clear context on when to use (list loans for connections/all banks) and how (pass items or omit). Does not explicitly exclude scenarios or mention alternative siblings, but the sibling get_loan_detail is implied for a single loan. No explicit when-not-to-use, but still 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 only declare readOnlyHint, idempotentHint, and destructiveHint; the description adds extensive behavioral context beyond those: automatic vs manual pagination, 5000-transaction truncation, scheduled/future-dated rows with 'scheduled:true', per-connector PENDING/POSTED variability, error return shape { total:0, results:[], warning, error }, the account echo block, and provider_incident behavior. No contradiction with annotations appears.

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

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

The description is very long, but it front-loads the core purpose and critical caveats and uses explicit labels for distinct topics like 'PAGINATION', 'SCHEDULED', and 'Bulk support'. Some repetition occurs, especially the billId 'per-connector HINT' warning appearing both early and in the rich detail section, which makes it denser than needed. Still, nearly every sentence adds a distinct decision-relevant point.

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

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

Without an output schema, the description fully outlines return behavior: automatic pagination, truncation notice, account echo, scheduled_count/notice, error fallback, provider_incident block, and per-credit-account sync troubleshooting. It even advises cross-checking the account echo and naming the bank when presenting results. An agent has enough context to invoke and interpret this 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 the description fully carries the parameter-weight. It explains account_id, account_ids (bulk), from/to ISO YYYY-MM-DD filters, search_queries OR/substring semantics and 5000-filter behavior, page/page_size manual vs auto pagination, and detail enum with compact/rich/raw behaviors. It successfully compensates for the missing parameter descriptions in the schema.

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

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

The description opens with a specific verb+resource statement: 'Returns transactions for a bank account (BANK or CREDIT type)' and clearly identifies a unique role: for CREDIT accounts this is the ONLY way to get itemized transactions. It also names the sibling context (openfinance_list_credit_card_bills) so the tool is not confused with bill-listing 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 gives explicit when-to-use guidance, including the exclusive use case for credit card itemization and which sibling tools to use instead: openfinance_list_credit_card_bills for standardized open-bill totals, openfinance_list_accounts for closing/due dates, and openfinance_get_item_status for sync health. It also states when not to use certain behaviors, e.g. 'Do NOT reconstruct a bill's total by summing transactions by billId' and 'do not derive a due date' from billForecastDate.

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), description reveals scan cap of 5000/account with truncation flag, provider incident block affecting data, and internal fan-out behavior. 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 dense and thorough, but could be more structured with bullet points for parameters. For 9 parameters and complex behavior, length is justified. Front-loads core purpose effectively.

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 full parameter disclosure, the description covers return values (compact summary fields, raw rows), truncation behavior, provider incidents, and bulk execution. No apparent gaps for an AI 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?

Despite 0% schema coverage, the description explains all 9 parameters: item (connector_id/name/item_id or omit), from/to ISO dates, granularity (monthly/raw), detail (compact/rich/raw), type (BANK/CREDIT), top_n (implied), and item_ids. Each parameter's meaning and usage is clearly 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 the tool performs consolidated cash-flow analysis for a bank connection in one call, distinguishing itself from sibling openfinance_list_transactions by eliminating the need to list accounts first. It specifies verb 'analyze' and resource 'connection transactions'.

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

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

Provides explicit when-to-use (e.g., 'análise anual/mensal', 'fluxo de caixa'), when-to-omit parameters (item for all connections), and alternatives (granularity 'raw' for itemized rows). Also mentions provider incidents and bulk support, guiding appropriate invocation.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, which is consistent with the description's 'Checks' verb. The description adds behavioral context: it returns global indicator, degraded components, open incidents, and flags incidents affecting connected banks, which goes beyond what annotations provide.

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

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

The description is somewhat long but each sentence adds value. It front-loads the core purpose ('Checks the LIVE operational status') and then provides usage guidance and return value details. It could be slightly more concise, but it is 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 there is no output schema, the description adequately explains the return values (global indicator, degraded components, open incidents, affected banks). It covers all necessary aspects for an agent to use the tool correctly, including the distinction from the sibling tool and when to invoke it.

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% (no params to cover). The description does not need to explain parameters. Baseline for 0 params is 4, which is appropriate.

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

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

The description clearly states the tool checks the LIVE operational status of the Open Finance provider, distinguishing it from the user's own connection status via `openfinance_get_item_status`. It specifies the verb 'Checks' and the resource 'provider status', and differentiates from siblings by naming the alternative tool.

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

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

The description explicitly tells when to use this tool: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It also explains what it helps diagnose (upstream outage vs. connection issue) and mentions the alternative tool `openfinance_get_item_status` for the user's own connection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context: it mentions the caveat for non-Open-Finance connectors and that without keywords it returns a hint, never dumping the whole catalog. No contradiction.

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

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

The description is relatively long but every sentence adds value, covering purpose, usage, parameter details, and special behaviors. It is 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?

Given no output schema, the description thoroughly explains what the tool returns (connector id, access, audience, linked connections, connect_url, caveat) and covers plan behavior and the hint response for empty keywords. It is complete for the tool's complexity.

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

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

With 0% schema description coverage, the description fully compensates by explaining that keywords is an array of strings (with examples) and is required, and that include_accounts affects whether accounts are returned. This adds essential meaning.

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

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

The description uses a specific verb 'searches' and resource 'bank connectors', clearly stating it returns connector id, access type, audience, linked connections, and connect_url. It distinguishes from sibling tools like openfinance_list_connections by focusing on keyword search.

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 'Call this BEFORE connecting to hand the user a one-click link to the right bank' and notes that keywords[] is REQUIRED. It also explains how the tool honors the user's plan, providing clear context for usage.

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

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

Discloses the side effect: automatically creates a Category Rule affecting future similar transactions. Also explains that it overrides automatic categorization and describes the batch return shape. No contradictions with annotations (readOnlyHint=false, etc.).

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 paragraph with front-loaded main action. Contains all necessary details but is moderately dense (over 100 words). Every sentence adds value, though a slightly more structured format could improve 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?

Given no output schema and minimal annotations, the description fully compensates: explains return shape, side effects, parameter sources, and batch error handling. Comprehensive for a batch update 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?

Despite 0% schema description coverage, the description thoroughly explains the items parameter structure, including the required fields transaction_id and category_id, and directs the agent to sibling tools for obtaining valid IDs. Adds meaning far 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?

Description starts with 'Corrects the category of one or more transactions (PATCH /transactions/:id)', using a specific verb and resource. It clearly distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories by focusing on updating categories.

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

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

Explicitly states when to use: 'use this to fix miscategorized transactions and improve categorization accuracy going forward'. Provides sources for IDs (openfinance_list_transactions, openfinance_list_categories). Lacks explicit when-not-to-use guidance but context strongly implies its purpose.

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 idempotentHint=true and destructiveHint=false, indicating safe re-call and non-destructive behavior. The description adds the behavioral detail that a conversation array should be included for reproduction. It does not contradict annotations and adds moderate 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?

The description is two sentences long, front-loading the purpose and following with a key usage instruction. 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 lack of output schema and 0% schema description coverage, the description should provide more detail. It omits what happens after reporting, the expected format of 'message', and how 'context' influences the report. The tool's overall behavior is only partially 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?

With 0% schema description coverage, the description must compensate. It only clarifies the 'conversation' parameter ('recent messages for reproduction') but does not explain 'context' or 'message'. 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 the tool's purpose: 'Report a bug, missing feature, or send feedback.' This is a specific verb ('report') and resource ('bug, missing feature, or feedback'). It is easily distinguishable from sibling tools, which are primarily financial operations and utilities.

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

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

The description advises to 'Include the conversation array with recent messages for reproduction,' providing some context for when to use the tool. However, it does not explicitly state when not to use it or suggest alternative tools, leaving the agent to infer usage boundaries.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds that it shows version info, but little else 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-loaded with key action and output, 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 full annotations, the description is complete and 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?

No parameters exist (100% schema coverage with empty properties). Baseline 4 applies; no parameter info 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. It's distinct from sibling tools like authenticate or 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?

No guidance is provided on when to use this tool vs alternatives. While trivial, the guidelines dimension requires explicit cues, which are absent.

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 behavioral context by detailing exactly what the return value contains (MCPs, status, accounts, tool counts), which is valuable given the absence of an output schema. The annotations already declare readOnlyHint=true and idempotentHint=true, and the description aligns with these without contradiction.

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

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

The description is a single, well-structured sentence that front-loads the action ('Returns the current toolkit state') and then lists the key components without any fluff or repetition.

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 convey what the user receives, and it does by listing major return elements. It is reasonably complete for a simple info tool, though it could mention formatting or detail level if relevant, but that's not critical here.

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 input schema provides no semantic burden. The baseline of 4 applies because the description doesn't need to explain parameters, and it correctly focuses on the output instead.

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

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

The description uses the specific verb 'Returns' and clearly identifies the resource as 'current toolkit state', enumerating concrete elements (installed MCPs, connection status, accounts, catalog tool counts). This distinguishes it from sibling tools that perform specific operations like authenticate or list accounts.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. While it's inherently an overview tool, the lack of any usage direction makes it a clear gap.

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