Banco Sofisa MCP

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

Annotations indicate idempotentHint=true and destructiveHint=false, and the description complements this by explaining token usage and session behavior. It warns about token persistence. However, it could explicitly state that calling with a token modifies session state, but it's implied.

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 (three sentences) and structured: it starts with purpose, then best practice, then usage options. No redundant 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 is simple with one optional parameter and no output schema, the description covers all necessary aspects: authentication flow, token options, and behavior. It is complete for an AI agent to 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?

Schema description coverage is 0%, but the description fully explains the single parameter 'token': it's a JWT from browser paste, and calls can omit it to get a link. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool is for authentication, detailing login via browser and token management. It distinguishes itself from sibling tools by focusing on this specific auth operation.

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 guidance is provided: best practice is to configure a permanent token in the server config, session-only by pasting token, or calling with no args to get a login link. This covers when and how to use the tool, including an alternative.

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 valuable behavioral context: the response structure (authenticated boolean, pending list, connect_url) and the two possible states. No contradictions.

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

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

Two sentences, each earning its place. First sentence states the core function, second sentence explains the two possible outcomes. 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 no output schema, the description fully explains the return values and the two states. It is complete for a simple status check tool with no parameters.

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

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

The tool has 0 parameters and schema coverage is 100%, so baseline is 4. The description adds value by explaining what the tool returns, which compensates 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 connection status and URLs, with specific examples of output when all providers are connected vs when credentials are missing. This distinguishes it from sibling tools like 'authenticate' and 'marketplace'.

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

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

The description implies when to use (checking connection status or getting URLs for missing credentials) but does not explicitly state when not to use or name alternatives. It gives good context but lacks explicit 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 discloses many behaviors not in annotations: invoke works even when the MCP is not installed and avoids bloating the tool list; credential/payment failures yield connect or checkout links with a retry instruction; writes require workspace owner/admin; search/describe flag installation state; publish_prompt returns a shareable no-login link. No contradiction with readOnlyHint=false or destructiveHint=false.

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 well structured: it front-loads the core search→describe→invoke flow, highlights the key invoke behavior, then distinguishes install vs invoke, lists auxiliary actions, states permission requirements, and covers the prompt library. Every sentence adds useful information for a 14-action, 23-parameter tool, so the length is justified.

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 high-complexity tool with no output schema, the description covers the central workflows, edge cases (credentials, payment, permissions), and the prompt-library subdomain well. It falls short on some details: the 'resume' action is never mentioned, and exact output shapes for search/describe/list_tools are not specified, though the description does say what key actions return.

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 carry the parameter burden. It does explain the action enum values and the roles of mcp_id, tool_id, arguments, prompt_vars, and prompt_slug through the described workflows. However, several parameters such as immediate, tier_slug, conversation, report_context, and request_name are not individually addressed, so it is not fully compensated.

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 by identifying the tool as 'the official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them', then explains the core search→describe→invoke flow and the separate prompt library. This clearly states what the tool does and distinguishes it from siblings like openfinance_* and authenticate.

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

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

It gives explicit when-to-use guidance: use search for capability requests, describe to inspect one MCP, invoke for one-off runs, install only for permanent toolkit membership, list_tools for currently callable tools, and request_mcp when nothing fits. It also says 'prefer invoke for a single/occasional use' and names alternatives, which is exactly what this dimension asks for.

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

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

Describes destructive effects (revoke consent, delete data) and return URL, adding value beyond the destructiveHint annotation. Could mention reversibility or side effects.

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

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

Two sentences, front-loaded with purpose, no filler. Efficient and clear.

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

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

Covers effect and return value, but parameter definition missing. For single-param tool, should specify what 'item' is.

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

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

Only parameter 'item' not explained; description says 'for a specific bank' but doesn't link to parameter. With 0% schema coverage, agent may not know what to provide.

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 revokes Open Finance consent and deletes connection data for a specific bank, with specific verb+resource. Distinct from sibling tools like connect or list.

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 use when disconnecting a bank, but no explicit guidance on when not to use or alternatives. Missing context like 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?

Describes polling behavior, timeout (~60s), return structure including status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, timed_out. Annotations are minimal but do not contradict; description adds extensive behavioral 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?

Well-structured with front-loaded purpose and step-by-step details. Slightly verbose but every sentence adds value.

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

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

Covers input, behavior, output, and error states comprehensively. No output schema but return values are described. Adequate for agent decision-making.

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

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

Both parameters (wait, items) are explained in full detail despite 0% schema coverage. Items includes valid selector types, and wait explains fire-and-forget mode.

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 re-sync and waits for completion. It distinguishes from siblings by explicitly comparing to openfinance_get_item_status and other tools for status checks versus sync initiation.

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 for stale data and explains how to use wait parameter. Mentions alternative for timed_out cases but does not explicitly list when to avoid using the tool.

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

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

Beyond annotations (readOnly, idempotent, non-destructive), the description reveals snapshot semantics, the meaning of updateDateTime/updatedAt, structured warnings instead of thrown errors, and degradation behavior for 5xx or non-Open Finance connectors. This is substantial behavioral context not available from annotations.

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

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

The description is long but every sentence delivers critical operational information: freshness caveat, comparison to transactions, sync trigger, error conditions, and degradation behavior. It is front-loaded with the core purpose and organized by importance without 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 there is no output schema, the description richly covers return semantics, error cases, and corrective actions. It tells the agent how to interpret rows, what triggers warning vs. error, and how to handle each failure mode, making the tool callable without missing key 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?

With 0% schema description coverage, the description compensates by specifying that account_ids must be an array of 1–50 items. It adds the size constraint and clarifies the array holds account identifiers, though it does not detail error behavior for invalid IDs or non-string entries.

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 and resource: 'Returns the latest available balance per account id' with an explicit endpoint. It distinguishes itself from siblings by clarifying this is a snapshot anchored to the last upstream sync, not a live read, which separates it from transaction listing and sync tools.

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

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

It gives explicit when-to-use guidance: if a balance is stale or disagrees with transactions, run openfinance_force_sync and re-read. It also explains handling of credit-specific errors by reconnecting the bank, which tells the agent what to do instead of failing.

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

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

Annotations indicate safe read-only behavior. Description adds critical warning about provider_incident block and unreliable data during incidents, plus batch shape with results/errors.

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?

Every sentence is purposeful, front-loaded with main purpose, no redundancy. Efficient use of 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?

With one parameter and no output schema, description fully covers input constraints, output shape, and a special case caveat. No obvious gaps.

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

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

Schema has no description for the only parameter. Description adds array size constraint (1-50) and context (batch shape). Compensates for low coverage with meaningful constraints.

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

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

Description clearly states it returns full account objects for given IDs, with specific details like creditData. Distinguishes from siblings by specifying per-ID batch retrieval.

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?

Implicitly says when to use: pass account_ids array 1-50. Lacks explicit exclusion of alternatives, but context is clear enough.

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

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

Annotations say `readOnlyHint=true`, `idempotent=true`, `destructive=false`, but the description much more than repeats those. It states the underlying provider lacks transactions on the credit card payload, that `totalAmount` is authoritative and must not be rebuilt by summing transactions, and that `payments[]` relates to a previous bill in Brazilian Open Finance, plus the cost of opt-in transactions. This materially sets the correct mental model for an 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, dense, and not flashy, but it is organied into purpose, transactions opt-in, authoritative data, and paid-status caveatotes, all of which are necessary for correct call in this domain. It could shed some parethesis nesting and repetitive references, but every piece does useful work.

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

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

The tool has no output schema, so the desription carries a critical burden and fully deliver: it gives bill rowfields, transactions[] behavior, the `transactions_basis` values with confidence/meaning, `{results, errors}` batch shape, and explicit guidance for the paid-status question. For a billing tool with these nuances, no crucial call-time decision 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 burden falls on the description, and it explains `bill_ids` (array, discover before use), `include_transactions` (needs `account_id` because the bill has no account ref), and the semantics of `account_id`. However, the `transactions_detail` enum (compact/rich/raw) is never explained, leaving a user without guidance as to its effect. Overall strong, but incomplete.

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?

It uses a specific verb+resource (returns bill-level detail by id) and scopes the user to GET /bills/:id while enumerating the exact fields and structures that will exist. It also distinguishes itself naturally from `openfinance_list_credit_card_bills` and `openfinance_list_transactions`.

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

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

The description gives explicit operational guidance: discover bill IDs with `openfinance_list_credit_card_bills`? pass `include_transactions:true` with `account_id` only when itemized purchases are needed; consult `transactiona_basis` to interpret confidence; and use `openfinance_list_credit_card_bills` when paid status is desired because this tool provides no status basis. This is excellent alternative-selection.

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

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

The description adds significant behavioral context beyond annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false). It explains the return structure including a reconnect_url feature and bulk execution support, which are not implied by 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 extremely concise at two sentences, with clear front-loading of the core purpose and structured breakdown of usage modes. Every sentence adds value without redundancy.

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

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

Given the tool has 3 parameters and no output schema, the description covers the return fields, two call patterns, and bulk support. It lacks error handling or rate limit information but is largely complete for a read-only status query 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?

With 0% schema description coverage, the description compensates by explaining the usage of 'item' (omit for all, pass for single) and 'item_ids' (bulk). However, it does not explicitly describe the 'item_id' parameter, which may cause confusion about its difference from 'item'. Overall, it adds meaningful semantics beyond the bare schema.

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

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

The description clearly states it returns the current status of a bank connection, listing specific output fields (status, executionStatus, connector metadata, reconnect_url) and distinguishes between single and bulk queries. It differentiates from sibling tools by describing its unique behavior of omitting 'item' to get all linked banks and supporting bulk via 'item_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 clear usage context: omit 'item' for all linked banks, pass 'item' for a single bank, and use 'item_ids' for bulk execution. However, it does not explicitly state when not to use this tool or mention alternative tools among siblings for other operations like syncing or disconnecting.

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 destructiveHint. Description adds context on batch response shape ({ results, errors }) and array size limit. 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?

Concise, front-loaded with purpose and key details. Every sentence adds value: purpose, usage, parameter details, response shape.

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 details many return fields and batch shape. Comprehensive given the tool's complexity and single required parameter.

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

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

Schema has 0% description coverage; description clarifies loan_ids is an array of 1-50 strings and mentions batch response shape, adding meaning beyond 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?

Clearly states returns full loan contract detail by ID, lists specific fields included. Distinguishes from sibling tool openfinance_list_loans by stating to use after for deep-dive.

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'. Also gives constraints on array size (1-50) and describes batch response shape.

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 read-only and idempotent, but the description discloses crucial behavioral nuances: connector-dependent credit balance semantics, balance_notice meaning, stale bankData fields after connection creation, provider_incident reliability warnings, and identity_notice deduplication guidance. This adds substantial value over the structured hints.

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 front-loaded with the core returns and uses clear topical sections for warnings. Some redundancy and a detached bulk-support note at the end make it less concise than ideal, but the length is justified by the number of subtle behavioral caveats.

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 carries the full burden and covers response structure (results vs root), field meanings, notices, and failure modes. It also routes to sibling tools for bill data, making the tool safe and correctly invocable without additional context.

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

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

The schema has 0% description coverage, and the description compensates well for item, type, and item_ids by explaining their effect on output. However, item_id is only mentioned as a response field tag, not clearly explained as a parameter for selecting a single connection, leaving one of four parameters under-specified.

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 verb (returns), resource (accounts), and account types (BANK/CREDIT), and enumerates the fields returned. It distinguishes itself from sibling openfinance_list_credit_card_bills by pointing to that tool for bill data, and the scope (all banks vs single bank) is 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?

Explicitly instructs when to omit item vs pass item, when to use openfinance_list_credit_card_bills instead for standardized bill amounts, and warns against treating CREDIT balance as the current bill. This is concrete how-to guidance beyond generic 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?

Beyond annotations (readOnlyHint, idempotentHint), the description adds caching behavior, single aggregated response, and no batch IDs. This fully discloses behavioral traits 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 concise with three sentences, front-loading the main purpose. Every sentence adds value (caching, response fields, language preference). No extraneous words.

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

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

Given no output schema, the description fully covers the response structure (id, description, descriptionTranslated, parentId, parentDescription) and operational details (caching, single response). Complete for a parameterless read 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?

With zero parameters and 100% schema coverage, the description does not need to explain parameters. The baseline score of 4 applies as no additional parameter info is required, but the description still adds value by detailing response fields.

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

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

The description uses specific verb 'Returns' and resource 'Pluggy's transaction category taxonomy', clearly identifying the tool's purpose. It distinguishes itself from sibling tools like openfinance_update_transaction_category by referencing the categoryId usage, making the scope distinct.

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 mentioning caching, single response, and preference for descriptionTranslated for Portuguese users. It indirectly guides when to use this tool (before updating categories), but lacks explicit when-not-to-use or comparison to other list tools.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds transparency by detailing the reconnect_url behavior (no disconnection needed, does not consume slot) and confirming the tool is a read-only listing 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, somewhat long sentence. It front-loads the main purpose ('Returns the saved bank connections for this install') but could be more concise by splitting into shorter sentences. Still, it conveys essential information without excess.

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 lists several return fields and explains the reconnect_url's purpose. It does not cover potential pagination, limits, or ordering, but for a simple list tool with no parameters, it is fairly 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?

There are no parameters, so schema coverage is trivially 100%. The description adds no param-specific meaning but provides context about what the returned data contains. This meets the baseline of 4 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 the tool returns saved bank connections and enumerates specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes from sibling tools by focusing on listing 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 provides context for using the reconnect_url (re-authentication, stale data) and notes it does not consume a slot. However, it does not explicitly guide when to use this list tool versus alternatives like list_accounts or list_transactions, leaving implicit that it's for connection-level info.

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 extensively discloses payment semantics, cross-bill payment matching, derived payment_status, connector asymmetry, reliability warnings, and opt-in behavior for open bill. These go well beyond the annotations which already indicate read-only and idempotent. 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 very verbose and lengthy, containing many caveats and details. While it is structured with capitalized sections, it could be more concise. Some information could be streamlined.

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

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

Given the complexity of the tool (5 parameters, no output schema, annotations present), the description covers all necessary aspects: return values, payment logic, connector behavior, alternatives, and edge cases. It is fully comprehensive.

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

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

The schema has 0% description coverage, so the description must compensate. It provides detailed guidance for include_open_bill and account_ids (bulk support), but does not describe page and page_size parameters. Thus partial coverage.

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

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

The description clearly states that the tool returns closed credit card bills for a CREDIT-type account, listing key fields. It distinguishes itself from siblings like openfinance_get_credit_card_bill and openfinance_list_transactions.

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

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

The description provides explicit guidance on when to use this tool (for closed bills) and when to use alternatives (openfinance_list_transactions for transactions). It also warns against summing transactions by billId. However, it does not explicitly exclude use cases like when only a single bill is needed.

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. The description adds critical behavioral details: graceful error handling (returns empty result on 403), data integrity warnings for mass zeroing, cross-checking transaction history, and flagging suspect rows. This goes well beyond the annotations.

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

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

The description is structured with clear sections and lists, but it is somewhat verbose. Key information is front-loaded, and every sentence provides value. A slight reduction in length 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 6 parameters with 0% schema coverage and no output schema, the description should cover more. It explains error handling and data integrity but lacks details on parameter roles and the full response structure beyond a partial example. Adequate but with gaps.

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

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

Schema description coverage is 0%, meaning the schema has no parameter descriptions. The tool description only mentions bulk support via item_ids but does not explain the purpose of parameters like item, page, type, or page_size. Thus, it adds minimal value to parameter understanding.

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 portfolios for a connection, listing specific asset types. It distinguishes itself from sibling tools like openfinance_list_accounts and openfinance_list_transactions by focusing solely on investments.

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 investment data but does not explicitly explain when to use this tool over alternatives such as openfinance_list_investment_transactions. No when-not-to-use guidance is 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 declare readOnlyHint=true and destructiveHint=false, confirming safe read. The description adds details about returned fields like expenses brokerageFee and incomeTax, and bulk support, going beyond annotations.

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

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

Two sentences: first explains output, second gives usage hint and bulk capability. Highly concise and front-loaded with 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?

With no output schema, the description lists returned fields (quantity, value, amount, netAmount, agreedRate, brokerageNumber, expenses) and prerequisite usage. Combined with sibling tools and annotations, it is fully adequate.

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

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

Schema description coverage is 0%, but the description clarifies investment_id and investment_ids (bulk). However, page and page_size are not explained, leaving some 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 it returns movement history for a specific investment position, listing transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER) and fields. It distinguishes from sibling tools like openfinance_list_investments (which lists positions) and openfinance_list_transactions (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?

It explicitly says 'Use after openfinance_list_investments to get the investment_id.' and mentions bulk support for investment_ids. This gives clear sequential context, though it does not explicitly exclude 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?

The description adds behavioral context beyond annotations: sequential querying with rate-limit spacing and the return format per connection. Annotations already indicate read-only and idempotent. Some details like pagination are omitted, but overall transparency is good.

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

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

Three sentences with no redundancy. The purpose is stated first, followed by parameter usage, then return format. Every sentence adds necessary information, achieving conciseness without sacrificing clarity.

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

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

Given no output schema, the description covers return structure. Complexity is low with one optional parameter. Sibling tools are accounted for. Missing potential pagination details, but overall adequate for the tool's simplicity.

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% with no parameter descriptions. The description fully compensates by explaining that `items` is an array of connection selectors (item_id, connector_id, or connector_name) and describes the effect of passing or omitting it. This adds high value.

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

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

The description clearly states that the tool lists loan contracts per bank connection, specifies the HTTP method path, and distinguishes its listing behavior from the sibling tool 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?

The description explains when to pass the `items` parameter (for specific connections) and when to omit it (to list across all banks). It also notes sequential querying with rate-limit spacing. However, it does not explicitly mention alternatives like get_loan_detail for a single loan, which would strengthen 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 only declare readOnly/idempotent semantics, but the description discloses several behavioral traps beyond that: descending-order future-first scheduling, `scheduled:true` flags, auto-pagination versus manual pagination, the 5000-transaction ceiling, per-connector inconsistency for `billId`, and provider incidents. It also exposes error shapes instead of claiming to always succeed.

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

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

The description is well-organized with clear semantic sections and front-loaded intent, but it is quite long and contains some repeated warnings (notably the `billId` caution appears both early and again in the `detail:'rich'` explanation). It is readable and structured, yet not perfectly lean.

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 must cover return semantics, and it does: `account` echo block, `total`, `results`, `scheduled_count`, `notice`, `warning`, `error`, and `provider_incident`. It addresses failure modes, sync issues, multi-bank attribution, and stateless context such as future-dated rows. Very little needed spec correct invocation 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 description coverage is 0%, but the description compensates richly: it explains `from`/`to` date formats, `search_queries` substring semantics, `page`/`page_size` auto-versus-manual pagination behavior, `detail` levels (`compact`, `rich`, `raw`), and bulk `account_ids` support. It adds meaning that cannot be inferred from the JSON schema at all.

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

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

The first line exactly says what the tool does: 'Returns transactions for a bank account (BANK or CREDIT type)', which names the verb, the resource, and the scope. It also clarifies that it is the only way to get itemized transactions for credit card accounts, which strongly separates it from account-level tools and bill-level 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 is unusually explicit about when to use alternatives: openfinance_list_credit_card_bills for authoritative bill totals, openfinance_list_accounts for statement closing/due dates, openfinance_get_item_status for sync health, and openfinance_force_sync as a remediation step. It also tells the agent when not to trust summed transactions for bill reconstruction and when to check scheduled rows.

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, destructiveHint), the description discloses important behavioral traits: scan caps at 5000/account with a truncated flag, and potential provider_incident block that may affect data completeness. These are not indicated by annotations and add significant 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 somewhat lengthy but front-loaded with the core purpose. Every sentence adds value, covering parameters, behavior, and output. However, it could be more structured (e.g., bullet points) for quicker scanning. Still, it is efficient and not 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?

Without an output schema, the description thoroughly explains return values: total entradas, saídas, saldo_liquido, monthly evolution (por_mes), top_despesas/top_recebimentos, per-account breakdown. It also covers error conditions (provider incident, truncation). For a 9-parameter tool with no output schema, this is remarkably 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?

With 0% schema description coverage, the description fully compensates by explaining all 9 parameters in detail. It specifies that 'item' can be connector_id, connector_name, or item_id; 'from'/'to' are ISO dates; 'granularity' defaults to 'monthly' (compact summary) vs 'raw' (consolidated transactions); 'detail' options (rich, raw) add merchant info or full object; 'type' filters BANK/CREDIT; 'top_n' is implied in top_despesas/top_recebimentos; 'item_ids' for bulk. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool's purpose: 'Consolidated cash-flow analysis for a whole bank CONNECTION over a period, in ONE call.' It distinguishes from siblings by explicitly noting that it resolves accounts internally, so the user does not need to call openfinance_list_accounts first. The verb and resource are specific and well-defined.

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: for 'análise anual/mensal', 'fluxo de caixa', 'entradas e saídas', 'maiores gastos/recebimentos'. It also advises when to use alternatives (e.g., set granularity to 'raw' for itemized rows, or combine with detail options). It explains parameter usage (omit item for all banks, ISO dates, etc.) and trade-offs (raw is heavier).

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

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

Annotations already indicate readOnlyHint and idempotentHint, so no mutation. Description adds details about live nature, public status page, and return values (global indicator, degraded components, open incidents, affected banks). 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?

Description is well-structured and front-loaded with purpose and differentiation. It is slightly lengthy but every sentence adds value. No wasted words, though could be tightened slightly.

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

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

For a simple read tool with no output schema, the description fully explains what it does, when to use it, and what it returns. No gaps remain.

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?

Tool has zero parameters and schema coverage is 100%, so description cannot add value there. Baseline 4 is appropriate as it is not required to elaborate further.

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 checks the LIVE operational status of the Open Finance provider, distinct from the connection status. It provides a specific verb ('Checks') and resource ('operational status of the Open Finance provider') and explicitly distinguishes from the sibling tool `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 tells when to use: when data looks incomplete or stale despite a connection showing UPDATED. It contrasts with the connection status tool, giving clear diagnostic context. No ambiguity about the intended use case.

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

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

Annotations indicate read-only and idempotent. Description adds important context: caveats for non-Open-Finance connectors, never dumps catalog, and plan restrictions. Does not mention error handling or rate limits, but overall strong.

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 a single dense paragraph but highly informative with no redundant sentences. Could be broken into sections for readability, but remains concise and front-loaded.

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

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

Covers search behavior, return fields, plan logic, caveats, and required parameter. No output schema, but description fully explains what is returned. Contextually complete for a search tool with sibling 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 is 0%, so description compensates well: explains keywords (including example) and include_accounts. Default values not explicitly stated but implied. Adequate for agent usage.

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 searches bank connectors by name and lists exact return fields, differentiating from sibling tools like connect and marketplace. It explicitly says 'Call this BEFORE connecting', establishing a clear purpose.

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: before connecting. Details required parameter (keywords[]), behavior without it (returns hint), plan handling, and preference for Open Finance connectors. No ambiguity.

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 annotations by detailing that recategorization creates a Category Rule for future similar transactions, teaching the system. It also outlines the side effect of overriding Pluggy's automatic categorization, which annotations did 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 a single paragraph that front-loads purpose and then provides necessary details. While dense, every sentence is informative. It could be slightly more structured with bullet points, but it remains clear and concise.

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

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

Given the complexity of a batch update with side effects and no output schema, the description covers all essential aspects: input format, ID sources, behavioral implications, error handling, and return shape.

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 the structure of the 'items' array, the required fields (transaction_id and category_id), their sources, and the batch response shape including error handling.

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

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

The description clearly states the tool corrects the category of transactions, specifies the REST endpoint (PATCH /transactions/:id), and distinguishes itself from sibling tools like openfinance_list_transactions and openfinance_list_categories by explaining the source of input 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?

It explicitly states when to use: to fix miscategorized transactions and improve future accuracy. It also explains that transaction_id comes from openfinance_list_transactions and category_id from openfinance_list_categories. However, it does not mention when not to use or provide alternative tools explicitly.

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 idempotentHint=true and destructiveHint=false, so the description adds no further behavioral context. It merely restates the intent without disclosing any additional traits (e.g., rate limits, delivery guarantees).

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

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

Two sentences efficiently define purpose and provide a key usage hint. Every sentence adds value, no redundant 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?

For a simple feedback tool with no output schema, the description covers the essential purpose and a key parameter hint. Minor gap: no description of the 'context' parameter or expected format for 'message'.

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 partially compensates by mentioning the 'conversation array' and its role for reproduction. However, it does not explain the 'context' or 'message' parameters, leaving gaps for an agent to infer correct usage.

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 'Report a bug, missing feature, or send feedback,' clearly defining the tool's purpose with a specific verb and resource. Among siblings (mostly openfinance tools), this stands out as a unique utility for issue reporting.

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

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

The description advises to 'Include the conversation array with recent messages for reproduction,' providing clear context for when to use this tool (reproduction-needed reporting). However, it does not explicitly state when not to use it or mention alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds value by specifying exactly what is shown (platform and adapter versions), contributing additional context beyond the annotations.

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

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

The description is a single sentence of 8 words, front-loaded with the key action and resource. Every word earns its place, and there is no fluff.

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

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

Given the tool has no parameters, no output schema, and a straightforward function, the description fully covers what the tool does. It provides complete context for a simple version query.

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, and schema coverage is 100%. With 0 parameters, the baseline is 4, and the description does not need to explain parameters further.

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

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

The description clearly states the tool's purpose: showing the current MCP platform and adapter versions. It uses a specific verb and resource, and distinguishes itself from sibling tools, none of which are version-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 implicitly states when to use it: to retrieve version information. No alternatives or exclusions are provided, but given the tool's simplicity, the context 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 declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds meaningful context about the exact content of the returned state, going beyond the structured annotations. No contradictions or undisclosed side effects are apparent.

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 main purpose ('Returns the current toolkit state') and immediately provides details. Every word 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?

For a parameterless, read-only info tool with no output schema, the description adequately covers the key aspects of the returned state: installed MCPs, connection status, accounts, and catalog tool counts. It leaves no major gaps, given the tool's simplicity.

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 description need not explain parameter semantics. Schema coverage is vacuously 100%, and the baseline score of 4 for no parameters 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's function: it returns the current toolkit state, enumerating specific components (installed MCPs, connection status, accounts, catalog tool counts). This distinguishes it from sibling tools like show_version or openfinance_provider_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?

There is no explicit guidance on when to use this tool versus alternatives such as openfinance_provider_status or openfinance_list_connections. It does not specify scenarios, prerequisites, or exclusions, leaving the agent to infer usage from the description alone.

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