Sam's Club MCP

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

The description adds context beyond annotations: idempotentHint is true, and description explains that calling with no args returns a link, while providing token completes login. 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 and well-structured, though slightly verbose. Every sentence earns its place, but could be trimmed slightly for 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?

Despite no output schema, the description covers the authentication flow completely: two login methods, how to call each, and what to expect. Sufficient for a simple parameter tool.

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

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

Schema has 0% coverage but description fully explains the single parameter 'token': 'call with { token: '<jwt>' } after the user pastes, or with no args to get the link.' 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 clearly states the tool handles authentication for MCP.AI IDE agents, describing two distinct login methods: permanent via config and session-only via token. This distinguishes it from sibling tools like 'connect'.

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

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

Explicitly guides when to use each method: 'add it to this server's config... for a permanent, non-expiring connection' or 'paste it here for a session-only login'. Also specifies calling with or without the token parameter.

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

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

Annotations already indicate readOnly and idempotent behavior. The description adds valuable details about return values in different states, enhancing transparency 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?

Two clear, front-loaded sentences with no wasted words. The description efficiently conveys the tool's purpose and behavior.

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

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

Given no parameters, good annotations, and no output schema, the description adequately covers the tool's behavior for a simple status check tool. It could mention authorization expectations but remains complete enough.

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 complete. The baseline for 0 parameters is 4, and the description adds no further parameter info (none 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 returns connection status and URLs with specific scenarios. It distinguishes itself from sibling tools like 'authenticate' by focusing on status checking.

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 by describing two states (all connected vs. credentials missing), but does not explicitly mention when not to use or list alternatives.

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

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

Beyond the sparse annotations (readOnlyHint=false, destructiveHint=false), the description discloses critical behavioral details: invoke runs tools even when not installed, may return connect or checkout links, and performs a one-off install. It also states that writes require workspace owner/admin and that invoke avoids bloating the tool list. These are significant behavioral insights not captured by 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 lengthy but each sentence introduces a distinct, valuable concept: the core flow, the key invoke behavior, install vs. invoke guidance, permission requirements, and the prompt library. It is logically structured but could benefit from bullet points or section breaks to improve scanability. Given the tool's complexity, the length is largely 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?

The description covers the tool's main purpose, key distinctions, and important caveats, making it usable for many common actions. However, with no output schema and undeclared parameter details, the description leaves gaps for less-common actions (e.g., resume, cancel with reasons, get_prompt with prompt_vars). It is reasonably complete for high-level usage but not fully self-contained for all 23 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 description indirectly explains some parameters by describing the core flow (e.g., query for search, mcp_id for describe, tool_id and arguments for invoke), and mentions prompt-related parameters for get_prompt/publish_prompt. However, with 23 parameters and 0% schema description coverage, many parameters remain opaque, such as immediate, conversation, prompt_vars, prompt_targets, and report_context. The description only partially compensates for the lack of schema-level documentation.

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

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

The description clearly identifies the tool as 'the official mcp.ai marketplace' and explains it as the catalog and execution mechanism for MCPs/tools. It specifies distinct actions (search, describe, invoke, install, subscribe, etc.) and differentiates from sibling tools by focusing on marketplace functionality rather than openfinance-specific operations. The core flow is explicitly laid out, making the tool's purpose unambiguous.

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

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

The description provides explicit when-to-use guidance: 'Use install only to make an MCP PERMANENT in the active toolkit... prefer invoke for a single/occasional use.' It also explains when to use subscribe/cancel, report_bug, and request_mcp, and distinguishes in-app catalog functions from prompt library actions. This directly helps an agent choose between marketplace actions and alternative sibling 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 destructiveHint=true. The description adds that the bank's data will no longer be available and that it returns an add_connection_url, providing useful behavioral context beyond annotations. No contradictions.

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

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

Two short sentences, front-loaded with the core action and consequences. No unnecessary words or 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 tool with one parameter and no output schema, the description covers the core action and result. However, it omits details about parameter format, error conditions, and prerequisites, leaving gaps for an AI agent to use it correctly.

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

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

Schema coverage is 0%, and the description does not explain the sole required parameter 'item'. It only says 'for a specific bank' without specifying the parameter's meaning (likely an identifier). This fails to compensate for the lack of schema documentation.

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

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

The description clearly states it revokes consent and deletes connection data for a specific bank, with a result that data is no longer available and returns a re-connection URL. This distinguishes it from sibling tools like openfinance_force_sync or 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?

The description implies usage when disconnecting a bank but lacks explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned, and prerequisites (e.g., having an active connection) are not stated.

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?

Despite annotations being minimal (no destructive/idempotent hints), the description fully discloses behavior: waits up to 60s, polls, returns status fields, handles `needs_action` with reconnect URL, and explains timeout behavior. 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 comprehensive but somewhat lengthy; however, every sentence adds value and it is well-structured with front-loaded purpose. Could be slightly trimmed but overall effective.

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 format (results/errors with status fields, needs_action, timed_out) and error handling. Covers all necessary context for an agent to use the tool correctly.

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

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

Input schema has 0% description coverage, but the description fully explains both parameters: `items` as array of selectors (item_id, connector_id, etc.) with omission meaning sync all, and `wait` as boolean for synchronous vs fire-and-forget.

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 forces a re-sync of bank connections and waits for completion. It distinguishes from sibling tools by specifying that it pulls fresh data without disconnecting/reconnecting, and mentions alternatives like openfinance_get_item_status for timed-out syncs.

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

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

Explicitly says when to use (when balance/transaction list looks stale), what not to do (no disconnect needed), and provides guidance on omitting items to sync all. Also explains the fire-and-forget option via `wait: false`.

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

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

Adds significant behavioral details beyond annotations (readOnlyHint, etc.): describes error handling with warnings, degradation to last-synced, and response shape. 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?

Front-loaded with purpose and endpoint, then details in a logical order. Could be slightly shorter but each 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 no output schema, the description fully explains the return shape and edge cases (errors, warnings, degradation). Handles all likely usage contexts.

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?

Describes the single parameter account_ids as an array of 1-50 strings, adding constraints not in schema (only type and items). Despite 0% schema description coverage, the description compensates fully.

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

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

Clearly states it returns real-time balance per account id with specific endpoint. Distinguished from siblings like openfinance_list_accounts and openfinance_get_accounts_detail by focusing on balance 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?

Provides constraints: account_ids array of 1-50 items. Explains error scenarios (CREDIT accounts may return error with warning; degradation to last-synced when institution unavailable). Does not explicitly state when to use over siblings, but the specificity suffices.

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, idempotent, non-destructive. Description adds critical context about provider_incident blocks and unreliable data, which goes beyond annotations. Warns against presenting incorrect values.

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 with front-loaded purpose. Four sentences with no redundancy. Could slightly tighten the provider incident explanation.

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?

Tool has one parameter, no output schema, but description covers return shape, edge cases, and usage constraints. All necessary information for agent invocation is present.

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 account_ids is explained with array size constraint (1–50) and meaning. 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?

Description clearly states the action: returns full account objects with extended creditData per ID. Specifies the HTTP endpoint and parameter shape. Differentiates from siblings by implying it's the detail endpoint.

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 array size limits (1–50) but no explicit comparison to sibling tools like list_accounts. Does not state prerequisites or when to prefer this 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 (readOnlyHint, idempotentHint), description adds critical context: batch response shape, missing paid/status field, payments reflecting previous bill, and recommendation for payment status via openfinance_list_credit_card_bills.

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 long but front-loaded with main purpose and well-structured. Each sentence adds value, though minor repetition exists (payments is explained twice). Slightly verbose for a single-parameter tool, but information density is high.

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 simple schema, no output schema, and basic annotations, the description comprehensively covers what the tool does, what it returns, how to use it, and important caveats. No gaps in context needed for correct invocation.

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

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

Schema coverage is 0%, but description clarifies that bill_ids is an array of strings to be discovered via openfinance_list_credit_card_bills, adding usage guidance. Could be slightly more explicit about format constraints, but sufficient for a simple parameter.

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

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

The description clearly states it returns bill-level detail (financeCharges, payments) for one or more bills by ID, explicitly listing what is and isn't included, and distinguishes it from openfinance_list_transactions for itemized transactions.

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

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

Explicitly tells when to use (for bill-level detail) and when not to (for itemized transactions, use openfinance_list_transactions), how to discover bill IDs via sibling tool, and batch response shape. Includes warnings about payments array interpretation.

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 and idempotentHint=true. Add reconnects widget in UPDATE mode without disconnecting or consuming a slot, which is useful behavioral context beyond what annotations provide.

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

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

Two sentences plus a brief bulk support note. Front-loaded with main purpose, 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?

No output schema, but description lists returned fields (status, executionStatus, connector metadata, reconnect_url). Could be more detailed about format, but sufficient for a read-only status tool.

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

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

Schema coverage is 0%, but description adds meaning: 'item' for single bank, 'item_ids' for bulk, though 'item_id' is not explained separately (likely alias). Adds value 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 the tool returns the current status of a bank connection, including specific values like UPDATED, UPDATING, LOGIN_ERROR, as well as executionStatus, connector metadata, and reconnect_url. Differentiates between bulk and single bank queries.

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 describes when to omit 'item' (get all banks) and when to pass 'item' (single bank). Also mentions bulk support via item_ids. Does not explicitly state when not to use, but 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 provide readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral details: batch processing (array of 1-50 IDs), error handling ('{ results, errors }'), and the extensive list of returned fields, 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?

The description is a single run-on sentence listing many fields, making it somewhat dense. While it conveys necessary information, it could be more concise and structured. The list of fields is exhaustive but not optimally formatted.

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

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

Given the tool's complexity (returns many fields) and no output schema, the description thoroughly covers return values by listing fields, explains usage context, and details batch behavior. It is complete for a read-only tool with one parameter.

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

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

Schema coverage is 0%, so the description must compensate. It specifies 'Pass `loan_ids` as an array (1-50)', adding a size constraint and clarifying the batch nature. The justification could be stronger if it explained the format of each ID, but it adequately adds 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?

Description starts with 'Returns full loan contract detail by id', clearly stating the verb (Returns) and resource (loan contract detail). It distinguishes from sibling tools by advising 'Use after openfinance_list_loans', providing a specific context.

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', giving clear when-to-use guidance. Does not mention when not to use, but the sibling list includes the prerequisite tool, making it 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 mark as read-only and idempotent. Description adds significant behavioral context: provider_incident affecting reliability, identity_notice for deduping, and connector-dependent credit balance meaning. 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 long but front-loaded with core purpose. Every sentence adds essential information. Could be slightly more concise but appropriate 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, description fully explains return fields and edge cases. Covers bulk support and special notices. No gaps 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?

Schema coverage is 0% but description explains `item`, `type`, and `item_ids` well. Misses explaining `item_id` (singular) which exists in schema but not in description. Overall good compensation for lack of schema descriptions.

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

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

The description clearly states it returns accounts for bank connections with specific fields (BANK/CREDIT, balance, etc.). It distinguishes from siblings like openfinance_list_credit_card_bills by noting when to use that tool instead.

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 on when to omit vs. pass `item` for listing all accounts or a single bank. Also advises when to use openfinance_list_credit_card_bills for standardized billing amounts. Includes caveats about provider incidents and identity notices.

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 caching behavior and response format (single aggregated, no batch), 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 two sentences, front-loaded with the main action, and every sentence adds necessary detail without verbosity.

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 value, including field purposes and language variants. It also connects to sibling tool (openfinance_update_transaction_category), making it contextually complete for an agent.

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

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

There are zero parameters, so schema coverage is 100%. The description adds valuable meaning by detailing the fields: 'id', 'description', 'descriptionTranslated', 'parentId', 'parentDescription', which aids the agent in understanding the response structure.

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 transaction category taxonomy, including the HTTP endpoint and caching behavior. It is distinct from sibling tools like openfinance_list_accounts because it explicitly targets 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?

The description implicitly guides usage by noting that the 'id' field is used by openfinance_update_transaction_category and that 'descriptionTranslated' is for pt-BR users. However, it does not explicitly state when to use this tool over others or provide 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by explaining the update mode behavior of reconnect_url, that it does not consume a slot or require disconnecting, 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 well-structured and informative, though slightly lengthy. It front-loads the purpose and bulletizes key outputs, making it easy to skim.

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

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

Given zero parameters and no output schema, the description adequately explains return values and usage context, leaving little ambiguity for an agent.

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

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

There are no parameters, so baseline is 4. No additional parameter information is needed.

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

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

The description clearly states the tool returns saved bank connections with specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url), distinguishing it from sibling tools by detailing the output and use cases for reconnect_url.

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 guidance on when to use the reconnect_url (for re-authentication, MFA, LOGIN_ERROR, stale data) and clarifies it does not consume a connection slot. However, it does not explicitly compare to all sibling tools for when to use this list vs others.

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 set readOnlyHint=true and idempotentHint=true, so the description adds significant behavioral context beyond that. It explains the complex payment mapping across bills, derived payment_status logic, connector asymmetry with open_bill availability, and warnings for bill grouping reliability. There is 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 very long and detailed, covering many edge cases and derivations. While every sentence adds important context, the overall length could be reduced without losing critical information. The structure is logical, starting with main functionality then edge cases, but it is not 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 the tool (derived fields, cross-bill payments, connector asymmetry), the description is remarkably complete. It outlines the return structure, derived payment_status, open_bill behavior, future_bills projections, warnings about reliability, and the account echo block. Without an output schema, this description provides all necessary context for correct 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?

The input schema has 5 parameters but 0% schema description coverage. The description explains account_id, account_ids, and include_open_bill in detail, but does not mention page and page_size parameters. While the description adds meaning for the mentioned parameters, the omission of pagination parameters results in incomplete parameter semantics.

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

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

The description clearly states the tool returns closed credit card bills for a CREDIT-type account with a detailed list of fields. It distinguishes itself from sibling tools like openfinance_list_transactions (for itemized charges) and openfinance_get_credit_card_bill (presumably single bill). The verb 'returns' and specific resource 'closed credit card bills' make the purpose highly clear.

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

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

The description explicitly states when to use this tool (to get closed bills and payment status) and when not to (e.g., for itemized purchases use openfinance_list_transactions). It provides caveats about payment assignment to bills and warns against using account balance for total debt. It also instructs to use open_bill and total_pending_debt for standard derived values. Alternative tools are named.

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

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

The description adds significant behavioral context beyond annotations: it explains the return structure, error handling for disabled products, and the data integrity check for mass zeroing. This complements the readOnlyHint and idempotentHint annotations 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 well-structured, with a clear first sentence stating the purpose, followed by details on return fields and a separate paragraph for data integrity. While it is lengthy, every sentence adds value, and the most important information is front-loaded.

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

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

Despite having no output schema, the description explains the return structure (fields like balance, amount, etc.) and error handling. It also details edge cases (data integrity warning). However, it could be more complete by describing parameter semantics more thoroughly.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'item_ids' for bulk support and implies filtering by 'type' from the enum, but does not explain other parameters like 'item', 'page', 'page_size'. The description adds some meaning but not enough to fully cover the 6 parameters.

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

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

The description clearly states the tool returns the investment portfolio for a connection, listing specific investment types. It distinguishes itself from sibling tools that focus on accounts, transactions, or balances by specifying the scope (FIIs, stocks, ETFs, etc.) and the connection requirement.

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 guidance on when the tool is appropriate (for connections with INVESTMENTS enabled) and how to interpret results, including error handling (returns a structure instead of throwing 403) and data integrity warnings. However, it does not explicitly compare to sibling 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 read-only, idempotent, non-destructive. The description adds value by detailing the return fields (quantity, value, netAmount, expenses breakdown, etc.) and bulk execution capability, which enhances understanding 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 concise, well-structured paragraphs. The first describes functionality and output, the second gives usage hint. Every sentence contributes essential information, 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 tool with no output schema, the description sufficiently outlines return data and usage. It lacks pagination details but overall is complete enough for an AI to use effectively.

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 should compensate. It explains investment_id and investment_ids but omits page and page_size. Thus, half the parameters lack semantic guidance.

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

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

The description clearly states it returns movement history for an investment position, listing specific transaction types (BUY, SELL, TAX, etc.) and the fields included. It distinguishes from sibling tools like openfinance_list_investments by specifying the use case and prerequisite.

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

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

Explicitly mentions to use after openfinance_list_investments to get the investment_id, providing a clear prerequisite. Also notes bulk support with investment_ids. Does not explicitly exclude alternatives, but the context is adequate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context: it queries sequentially with rate-limit spacing and returns per-connection results/errors, which is beyond the annotations. No contradiction.

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

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

The description is extremely concise at two sentences, front-loaded with the core purpose, and every word adds value. No redundant or extraneous information.

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

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

Given the tool's complexity (optional filtering, no output schema), the description is complete: it covers input options, behavioral details (sequential, rate-limit), and return structure ({ results, errors } per connection). Annotations cover safety, and no additional context is needed for correct invocation.

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

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

The input schema has only one optional array parameter with no description (0% coverage). The description fully compensates by explaining that each element is a connection selector (item_id, connector_id, or connector_name) and what happens when the parameter is omitted, adding high semantic 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 it lists loan contracts per bank connection, specifies the HTTP method and path (GET /loans), and distinguishes itself from siblings like openfinance_get_loan_detail by focusing on listing multiple loans rather than a single 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?

Provides clear guidelines on how to use the tool: pass an array of connection selectors in `items` to fetch specific connections, or omit `items` to list all linked banks. It also mentions sequential querying with rate-limit spacing, but does not explicitly compare to alternative tools like openfinance_get_loan_detail for specific use cases.

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, destructiveHint=false, idempotentHint=true, and the description adds extensive behavioral traits: billId is a per-connector hint, PENDING vs POSTED varies, auto vs manual pagination with 5000 ceiling and truncated flag, error handling returns specific structure, provider incident block, and response includes account echo. No contradiction with annotations.

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

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

The description is long but well-structured with clear sections. It is front-loaded with the main purpose and each sentence adds necessary detail. Minor verbosity is justified given 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 the tool's complexity (8 parameters, credit nuances, pagination, error handling, provider incidents, bulk support), the description covers all critical aspects. It explains response structure, references sibling tools, and handles edge cases like upstream errors and zero transactions. No significant 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 coverage is 0%, but the description explains all 8 parameters: from/to (ISO dates), search_queries (case-insensitive substring, OR semantics, max 5000), detail (compact/rich/raw with what each adds), page/page_size (auto vs manual pagination logic), account_id (required), account_ids (bulk). It compensates fully for missing schema documentation.

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

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

The description clearly states the tool returns transactions for bank accounts, distinguishes BANK vs CREDIT, and for CREDIT it is the only way to get itemized transactions. It also differentiates from openfinance_list_credit_card_bills for bill totals.

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

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

Provides explicit when to use (e.g., for itemized credit transactions, not for bill totals), when not to use (e.g., don't reconstruct bill totals by billId), and context for pagination modes, search queries, date filters, and cross-checking account echo. Also references sibling tools for bill total and 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?

Annotations already indicate readOnly and idempotent. Description adds behavioral traits: internal resolution of accounts, truncation at 5000/account with flag, provider incident block, and compact vs raw output. 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 long but well-structured with clear sections. It front-loads the core purpose and adds details progressively. Could be slightly more concise, but every sentence adds value 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?

For a tool with 9 parameters, no output schema, and moderate complexity, the description covers output shape, limitations, provider incidents, and bulk support. Almost 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?

Schema description coverage is 0%, but the description adds detailed meaning for all parameters: item, from/to (ISO dates), granularity (monthly/raw), detail (compact/rich/raw), type (BANK/CREDIT), top_n (implied), item_ids (bulk). Defaults and effects are explained.

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 provides consolidated cash-flow analysis for a whole bank connection in one call, resolving accounts internally and aggregating transactions. It differentiates from siblings by avoiding the need to call openfinance_list_accounts first.

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 on when to use (for consolidated analysis without per-account listing), how to target one bank or all, and when to use different granularity and detail levels. Does not explicitly state when not to use vs alternatives like openfinance_list_transactions, but 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 destructiveHint=false. The description adds behavioral context by explaining it checks a public status page (no mutation) and lists the data returned (global indicator, degraded components, etc.), which is useful 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 slightly long but well-structured and front-loaded with the core purpose. Every sentence adds value—no waste. It could be marginally shorter but remains effective.

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

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

For a tool with no parameters and no output schema, the description is remarkably complete: it explains the tool's purpose, usage scenario, differentiation from siblings, and what the response will contain. No gaps.

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

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

No parameters exist, and schema coverage is 100%. According to guidelines, baseline is 4 for 0-param tools. The description does not need to add parameter info.

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

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

The description clearly states the tool checks the LIVE operational status of the Open Finance provider via its public status page. It explicitly distinguishes from the sibling tool `openfinance_get_item_status` by specifying it checks provider health, not user connections.

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

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

The description provides explicit when-to-use guidance: 'Use it whenever data looks incomplete or stale even though a connection shows UPDATED...'. It also contrasts with the sibling `openfinance_get_item_status` to avoid confusion.

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

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

Annotations already mark it as read-only and idempotent. The description adds significant context: caveat warnings for non-Open-Finance connectors, plan-based filtering, and that without keywords it returns a hint instead of dumping the catalog. 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 a single dense paragraph that could be more structured (e.g., bullet points). While front-loaded with the main action, it buries important details like the plan behavior and caveat. Slightly verbose for the information conveyed.

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 return fields and covers plan behavior, caveats, and required keywords. Minor omissions: no mention of pagination, limit, or error handling, but the essential behavior is well captured.

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 explains both parameters: keywords (array of strings, required, used to search by name) and include_accounts (boolean to include accounts). It also clarifies the requirement for keywords 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 searches bank connectors by name, lists the specific fields returned (connector id, access, audience, etc.), and explicitly distinguishes from sibling tools by noting it should be called before connecting to get a one-click link. No ambiguity.

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

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

The description explicitly says to call this before connecting, notes that keywords[] is required (otherwise returns a hint), and explains plan behavior for PF vs PJ. However, it does not explicitly contrast with other search or list tools like openfinance_list_connections.

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

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

The description fully discloses the side effect of creating a Category Rule that affects future categorization, and mentions batch behavior with per-item error handling. Annotations provide no conflicting hints, so the description adds significant behavioral context.

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

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

The description is concise, front-loaded with the purpose, and structured to deliver key information efficiently 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 no output schema, the description provides the return shape, explains side effects, and covers batch behavior. It is fully informative for a mutation tool of this 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?

Although the schema has no description coverage (0%), the description explains the 'items' parameter structure and the origin of fields (transaction_id, category_id), adding essential meaning 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 the tool corrects transaction categories, specifies the HTTP method PATCH and resource, and distinguishes itself from sibling list tools. It uses a specific verb ('Corrects') and resource ('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 the tool (to fix miscategorized transactions) and where to obtain required IDs (from openfinance_list_transactions and openfinance_list_categories). It lacks explicit when-not-to-use scenarios but provides sufficient guidance for correct 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 already indicate idempotent and non-destructive behavior. The description adds guidance on including conversation data for reproduction, but does not disclose additional side effects or behaviors beyond what annotations cover. It does not contradict annotations.

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

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

The description is extremely concise at two sentences, no redundant information, and front-loads the primary purpose. Every word serves a purpose.

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

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

For a simple tool with few parameters and no output schema, the description covers the primary action and one key parameter. However, it omits details on the 'context' parameter and what happens after reporting (e.g., response, ticket creation). Still sufficient for basic use.

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

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

With 0% schema description coverage, the description must compensate but only partially explains the 'conversation' parameter ('Include the conversation array with recent messages for reproduction'). The required 'message' is implied by the purpose but not detailed, and 'context' is not mentioned at all. Many parameters lack semantic clarity.

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.' It uses a specific verb ('report') and identifies the resource (bug/feedback). The tool is distinct from sibling tools, which are mostly Open Finance related, so no confusion.

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 the tool (when encountering a bug or needing to send feedback) and instructs to include the conversation array for reproduction. However, it does not explicitly state when not to use or mention alternatives, but given the uniqueness of this tool among siblings, it's 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, idempotentHint, and destructiveHint. The description adds that it shows both platform and adapter versions, providing some context beyond annotations but not 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?

One concise sentence with no extraneous information.

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

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

The tool is simple; the description covers its purpose adequately. No output schema, but the output is implied from the description.

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

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

No parameters, so schema coverage is 100%. Baseline is 4 for 0 parameters. The description does not need to add parameter info.

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

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

The description clearly states it shows MCP platform and adapter versions, using a specific verb and resource, and it is distinct from sibling tools.

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

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

The description implies when to use (to retrieve version info), but does not explicitly mention when not to use or provide alternatives. However, given the tool's simplicity, this is sufficient.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the content of the state but no extra behavioral traits like latency, prerequisites, or error conditions. It doesn't contradict annotations.

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

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

The description is a single sentence, front-loaded with the primary action ('Returns the current toolkit state'), followed by a compact list of contents. No redundancy or 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 zero-parameter, read-only info tool with no output schema, the description sufficiently enumerates the return value. It covers the main components an agent would need to know, and since there are no params or complex behaviors, nothing critical 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?

The tool has zero parameters, and the schema coverage is 100% (empty properties). Baseline for 0 params is 4, and the description doesn't need to add parameter semantics. It fully describes the return scope relevant to the absent parameters.

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

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

The description clearly states the tool returns 'the current toolkit state' and enumerates specific components (installed MCPs, connection status, accounts, catalog tool counts). This distinguishes it from sibling tools that handle specific operations like authentication or individual account listings.

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 a read-only overview use case, clearly positioned as a top-level status report. While it doesn't explicitly list when-not-to-use or alternatives, the context of 'toolkit state' makes it clear this is the go-to for a global snapshot, distinct from per-entity tools like openfinance_list_connections.

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