Caixa Tem MCP

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

Annotations indicate idempotentHint=true and no destructive effects. The description adds value by explaining that calling with no args returns a login link, and with a token it processes the JWT. It also explains the difference between permanent and session tokens, which is beyond what annotations provide.

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

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

The description is informative but slightly verbose. It front-loads the purpose and provides structured steps, but could be more concise without losing clarity. Some repetition exists (e.g., 'log in in the browser').

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

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

For a simple authentication tool with one optional parameter and no output schema, the description provides sufficient context: what it does, how to use it in two scenarios, and the expected behavior. It covers the key aspects an agent needs 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?

The input schema has one parameter 'token' with 0% description coverage. The description compensates by explaining how to use the token parameter: 'call with { token: '<jwt>' }' for session login, and clarifies its role. This adds essential meaning.

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

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

The description clearly states the tool's purpose: authentication for MCP.AI IDE agents. It explains two distinct methods (config token for permanent connection, session token via parameter). It distinguishes itself from sibling tools like 'connect' by focusing specifically on authentication.

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

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

The description provides explicit when-to-use guidance: for logging in. It offers a best practice (adding token to config) and an alternative (pasting token as a session parameter). While it doesn't explicitly state when not to use, 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?

Description adds context beyond annotations by detailing return values (authenticated, pending, connect_url) and behavior in two states. Aligns with readOnlyHint and idempotentHint.

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, then scenario details. No wasted words – every sentence adds value.

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

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

For a zero-parameter, read-only tool, the description fully covers behavior and return values (though no output schema). Annotations cover safety. Complete for its 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?

No parameters exist, so schema coverage is effectively 100%. Description does not need to add parameter info, and baseline of 4 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?

Description specifies it returns connection status and URLs, and distinguishes two scenarios (all connected vs missing credentials). This clearly identifies the tool's purpose and differentiates it from siblings like '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?

Description implies usage for checking connection status before operations, but does not explicitly state when to use or avoid, nor mention alternatives among siblings.

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

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

Goes far beyond annotations by disclosing that writes require workspace owner/admin, that invoke runs without installing the MCP, and that it returns connect/checkout links with a retry workflow. It also explains the permanent vs. one-off semantics of install. 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 dense, single paragraph that is long but every sentence adds value. It could be improved with bullet points or section breaks for the different action groups (MCP discovery, invocation, prompt library), but it remains highly informative.

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

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

Covers the main flow, edge cases (auth, payment, permissions), the prompt library, and the distinction between invoke and install. Lacks explicit return-format details and leaves some actions like 'resume' unexplained, but given the tool's complexity and lack of output schema, it 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?

The description explains the central 'action' parameter and its values in detail, and adds meaning to tool_id, arguments, prompt_vars, etc. through the workflow narrative. However, with 23 parameters and 0% schema coverage, some parameters like limit, query, cancel_reason enums, and resume are not explicitly described.

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

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

The description clearly identifies this as the mcp.ai marketplace catalog and execution engine, with an explicit core flow (search → describe → invoke). It enumerates all sub-actions and distinguishes the tool from sibling Open Finance/auth tools by stating its specific role.

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 guidance: prefer invoke for one-off runs, use install for permanent toolkit additions, and list_tools for currently callable tools. It also explains the core discovery flow and what to do when credentials or payment are 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 provide destructiveHint: true. The description adds context: 'deletes the connection data' and 'data will no longer be available', plus mentions the returned add_connection_url. This goes beyond annotations with useful behavioral details.

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

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

Two clear sentences with no wasted words. Front-loaded with the main action, followed by consequence and return value. 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?

For a simple tool with one parameter and no output schema, the description is fairly complete: it covers action, effect, and return. However, it could note reversibility or prerequisites. Still 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?

The schema has one parameter 'item' with no description (0% coverage). The description says 'for a specific bank', giving minimal semantics. It doesn't clarify format, source, or examples. Adequate but could be improved.

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 revokes consent and deletes connection data, with the specific verb 'revokes' and resource 'Open Finance consent for a specific bank'. It also mentions the return of a reconnection URL, distinguishing it from siblings that list or sync data.

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

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

The description implies usage when needing to disconnect a bank, but lacks explicit guidance on when not to use or alternatives. No exclusion criteria or comparison with sibling tools like openfinance_get_item_status or 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?

Discloses waiting behavior (up to ~60s), polling mechanism, return statuses, MFA handling with reconnect_url, and that it does not disconnect/reconnect. No contradiction with annotations (readOnlyHint=false, 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?

Description is detailed but well-structured, with key action and wait behavior front-loaded. Slightly long but each sentence adds value; could be more concise without losing clarity.

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

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

For a tool with no output schema, description covers output format (results, errors, synced, etc.), error states (MFA, timeout), and reconnection guidance. Comprehensive 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?

Despite 0% schema coverage, description fully explains both parameters: items as array of selectors (item_id, connector_id, etc.) and wait as boolean for fire-and-forget mode, adding essential meaning beyond the schema.

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

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

Description explicitly states the tool forces bank re-sync, waits for completion, and returns results. Clearly differentiates from sibling tools like openfinance_get_item_status and alternatives like disconnect/reconnect.

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 guidance ('balance or transaction list looks stale'), how to use (pass items array or omit for all), and alternatives (fire-and-forget with wait:false, re-check with openfinance_get_item_status on timeout).

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

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

Annotations already mark the tool read-only and idempotent. The description adds substantial behavioral context: the balance is a snapshot of the last upstream sync rather than a live read, credit accounts may return structured warnings for BALANCE_FETCH_ERROR/BALANCE_CONSENT_ERROR, and non-Open-Finance or 5xx upstream failures degrade gracefully. 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 dense but not wasteful: it front-loads purpose, then covers freshness caveats, error modes, and usage constraints. Every sentence adds operational value, though it is on the longer side for a one-parameter read tool.

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 effectively covers what an agent needs: snapshot timing, response row fields (updateDateTime/updatedAt, warning), error modes, and array limits. It stops short of providing the full response JSON shape, but the available detail is sufficient for correct invocation and interpretation.

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 provides the 1–50 array constraint for account_ids and clarifies that the parameter must be passed as an array. The meaning of account IDs is left implicit, but the parameter name is self-explanatory.

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

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

States a specific verb ('Returns'), resource ('latest available balance per account id'), and endpoint (GET /accounts/:id/balance). It also differentiates from siblings like openfinance_list_transactions and openfinance_force_sync by positioning what this tool uniquely provides.

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?

Gives explicit guidance to run openfinance_force_sync when balances are stale or disagree with openfinance_list_transactions, then re-read. It also constrains account_ids to 1–50. It does not explicitly state when not to use the tool, but the alternative path 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?

Adds significant behavioral context beyond annotations: warns about `provider_incident` block with unreliable credit limits and balances, and instructs not to present those values as real. Annotations already declare readOnlyHint and idempotentHint, which align with the description.

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 well-structured sentences with front-loaded purpose. Each sentence adds value, though the incident warning could be slightly more concise without losing meaning.

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

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

Covers return shape (full account objects with creditData, batch `{ results, errors }`), parameter constraint (array 1-50), and a special case (provider_incident). Lacks details on other account fields, but given no output schema, this 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?

The only parameter `account_ids` has no schema description coverage (0%), so the description compensates by specifying it as an array of 1-50 strings. This adds meaning beyond the bare schema type.

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

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

Clearly states it returns full account objects with extended creditData per id and mentions the HTTP endpoint. Distinguishes from sibling tools like openfinance_list_accounts by specifying per-id detail and inclusion of creditData.

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 specific guidance on passing `account_ids` as an array of 1-50 items and notes the batch shape `{ results, errors }`. However, it does not explicitly state when to use this tool versus alternatives like `openfinance_list_accounts` or `openfinance_get_account_balance`.

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

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

The annotations already indicate read-only and idempotent behavior, but the description goes much further by disclosing that no paid/status field exists, that payments[] refer to the prior cycle, and that transactions_basis may be exact or estimated. It also warns that totalAmount is authoritative and should not be recomputed from transactions, which is essential for correct use and differentiates this tool well.

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 each sentence adds a distinct operational fact. It is front-loaded with the core behavior and key output fields, then layers caveats and admonitions only where needed. There is no filler or redundant repetition of the schema.

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

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

For a tool with no output schema, the description is unusually complete about response shape, edge cases, estimate semantics, and parameter interactions. The only notable gap is the undocumented transactions_detail parameter and its compact/rich/raw differences. Overall, a capable agent could safely call this tool despite missing that one detail.

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% descriptions, so the description carries the burden of explaining parameters. It explains bill_ids, account_id, and include_transactions with meaningful behavioral context. However, the transactions_detail enum (compact, rich, raw) is never mentioned or explained, leaving a material parameter undocumented.

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

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

The description opens with 'Returns bill-level detail for one or more credit card bills by id', naming the specific verb, resource, and HTTP endpoint. It lists concrete response fields such as dueDate, billClosingDate, totalAmount, and payments[], and clearly positions itself relative to sibling tools by instructing bill discovery via openfinance_list_credit_card_bills.

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

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

The description gives explicit routing: 'use openfinance_list_credit_card_bills first to discover ids', 'prefer openfinance_list_credit_card_bills' for paid status, and openfinance_list_transactions for fetching transactions manually. It also explains when include_transactions is useful and when the transactions basis is an estimate, so the agent knows exactly when this tool is the right choice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, which are consistent with a read-only operation. Description adds useful behavioral details: the reconnect_url reopens widget in UPDATE mode without disconnecting or consuming a connection slot. 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?

Description is well-structured: first sentence states output and includes important detail about reconnect_url; second sentence covers parameter usage. Slightly verbose but no unnecessary words. Could be more concise by combining sentences.

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

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

Given there is no output schema, description adequately covers return fields and behavior for single vs all banks. Lacks explanation of error handling or edge cases, but overall complete enough for a status retrieval tool with clear annotations.

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

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

Schema has 3 parameters with 0% description coverage. Description explains 'item' and 'item_ids' but does not mention 'item_id' parameter, which may be an alias or redundant. This is a minor gap; the description adds meaning beyond the raw schema but incomplete for all 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?

Description clearly states it returns the current status of a bank connection, listing specific output fields (status, executionStatus, connector metadata, reconnect_url). It distinguishes between single bank and all banks usage, and mentions bulk support with 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?

Explicitly explains when to use the tool (to get connection status) and how to use parameters: omit 'item' for all banks, pass 'item' for a single bank, or use 'item_ids' for bulk. However, does not explicitly state when not to use or compare to alternative tools, though context from sibling names implies uniqueness.

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, idempotentHint, and destructiveHint, so safety is clear. The description adds context about the batch response format and that it returns detailed fields, but no behavioral contradictions.

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

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

The description is concise and informative, with a single sentence listing fields and a note about usage. Could be slightly more structured (e.g., separate sections) but overall efficient.

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

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

No output schema, but the description enumerates many returned fields. It adequately explains what the tool returns. Missing details on error format but still sufficient for its purpose.

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 the loan_ids parameter: it's an array, accepts 1-50 IDs, and returns a batch shape. 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 returns full loan contract detail by ID, lists specific fields, and names the endpoint. It distinguishes from sibling openfinance_list_loans by noting this is a deep-dive tool.

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

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

Explicitly instructs to use after openfinance_list_loans for deep-diving. Also specifies the allowed number of loan_ids (1-50) and batch output shape { results, errors }.

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

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

Even with readOnlyHint and idempotentHint annotations, the description adds substantial behavioral context beyond structured data: connector-dependent CREDIT balance semantics, balance_notice meaning, lagging bankData fields, provider_incident reliability warnings, and identity_notice dedup instructions. Nothing contradicts 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 front-loaded with the main return shape and is information-dense, but it is exceptionally long. Several caveats (balance_notice, bankData lag, provider_incident, identity_notice) could be condensed or grouped, and the repeated pointers to openfinance_list_credit_card_bills make it less concise than it could be.

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

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

Given no output schema and a complex financial domain, the description covers response fields, parameter behavior, cross-tool references, edge cases, and data reliability issues. An agent has enough context to call the tool correctly and interpret ambiguous or dangerous response states.

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

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

Schema description coverage is 0%, so the description carries the full burden. It clearly explains `item` (single bank), omission of `item` (all banks), and `item_ids` (bulk support), and the BANK/CREDIT type enum is mirrored in the feature explanation. However, the singular `item_id` parameter is not explicitly differentiated from `item`, leaving a small 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 uses a specific verb ('Returns') and names the exact resource and fields ('accounts for a bank connection: BANK ... and CREDIT ... with balance, number, type, subtype, bankData, and creditData'). It clearly distinguishes the tool's scope from related list tools, especially openfinance_list_credit_card_bills, so an agent can understand what this tool provides.

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

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

The description gives explicit when-to-use guidance: omit `item` for all linked banks, pass `item` for a single bank, and use openfinance_list_credit_card_bills when the user needs standardized open-bill amounts. It also names alternatives for force sync reconciliation and bill details, making the routing decision nearly unambiguous.

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 details beyond annotations: caching behavior, single aggregated response, and explanation of fields (id, description, descriptionTranslated, parentId, parentDescription). Annotations already declare readOnlyHint=true and 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 two sentences that front-load the main action and provide essential details without any fluff or 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?

Given the tool's simplicity (no parameters, no output schema), the description is complete. It explains purpose, caching, field details, and relation to sibling tool. 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?

There are no parameters, and the input schema is empty (100% coverage). The description adds value by explaining the output structure and field meanings, compensating for the lack of an 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 Pluggy's transaction category taxonomy, cached for the session. It distinguishes from siblings by noting that the `id` field is used by `openfinance_update_transaction_category`.

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

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

The description implies usage for retrieving categories and mentions the relationship with the update tool. However, it does not explicitly state when to use this tool versus alternatives or when not to use it.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint false. The description adds useful behavioral context about the reconnect_url behavior (reopens widget in UPDATE mode) and the add_connection_url. It does not contradict annotations and goes beyond basic read-only behavior.

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

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

The description is a single paragraph that packs several key pieces of information (what is returned, what each URL does). While not extremely concise, every sentence adds value and there is 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?

The description covers the return fields and explains the semantics of the reconnect_url and add_connection_url. With no output schema, it provides sufficient context for the agent to understand the output and 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 tool has no parameters; schema coverage is 100%. The description adds no parameter information because none exist. However, it details the output structure, including the reconnect_url and add_connection_url, which adds value beyond the schema.

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

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

The description clearly states the tool returns saved bank connections and lists specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes itself from sibling tools like connect and disconnect by explaining that reconnect_url is for re-authentication without consuming a slot.

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

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

The description provides explicit guidance on when to use the reconnect_url (re-authentication, LOGIN_ERROR, stale data) and what it does not do (consume connection slot, require disconnecting). This helps the agent choose between this tool and alternatives like connect.

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, destructiveHint), the description extensively details payment mapping, derived payment_status, connector asymmetry, reliability warnings, bulk support, and what happens when CREDIT_CARDS is not enabled. No contradictions with annotations.

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

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

The description is long but front-loaded with the core purpose. Every paragraph adds necessary context for the complex domain. Some verbosity could be trimmed (e.g., payment_status derivation), but overall it is well-structured and informative.

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

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

Given the complexity, zero schema coverage, and no output schema, the description is remarkably complete. It covers return fields, edge cases, warnings, parameter behavior, and alternative tools, leaving few gaps for the agent.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It covers account_id, account_ids, and include_open_bill in detail, but does not describe page and page_size, leaving a gap. Baseline 3 is appropriate for partial compensation.

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

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

The description clearly states the tool returns closed credit card bills for a credit-type account, listing specific fields. It distinguishes itself from sibling tools like openfinance_list_transactions and openfinance_get_credit_card_bill, and warns against misuse such as reconstructing bill totals from 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 vs. alternatives, e.g., 'To see itemized purchases/charges, use openfinance_list_transactions'. It also advises against using account balance for debt and warns about payment semantics and connector asymmetry.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds significant detail: return structure, error handling (returns total:0 instead of throwing), and crucially, data integrity warnings with cross-referencing and suspect_zeroed flag. This goes well beyond the annotations, providing deep 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 lengthy and detailed, with two dense paragraphs plus a bulk note. It is front-loaded with purpose but could be more concise. Some redundancy exists (e.g., repeating 'balance' and 'amount'). Acceptable for complexity but not optimally 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 no output schema, the description explains return fields and edge cases (mass zeroing) well. However, it does not cover pagination (page, page_size) or describe all parameters. Adequate for basic use but incomplete for full understanding.

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

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

Schema coverage is 0%, so the description must explain parameters. It only mentions 'item_ids' for bulk support. Parameters like item, page, type, item_id, page_size are not described. Minimal added value beyond the schema.

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

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

The description clearly states it returns an investment portfolio for a connection, listing specific asset types (FIIs, stocks, etc.). The verb "Returns" and resource are specific. However, it does not explicitly differentiate from sibling tools like openfinance_list_investment_transactions, though the purpose is distinct enough.

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

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

The description implies usage for retrieving portfolio data but provides no explicit guidance on when to use versus alternatives (e.g., when to use this vs list_investment_transactions). It mentions error handling for when INVESTMENTS is not enabled, but no exclusions or best practices.

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, idempotentHint, destructiveHint. Description adds behavioral details: returns itemized expenses (brokerageFee, incomeTax, etc.) and supports bulk execution. 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?

Two concise paragraphs with no unnecessary words. First paragraph defines purpose and output, second gives usage hint and bulk feature. Every sentence adds value.

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

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

Given no output schema, the description details output fields (quantity, value, amount, netAmount, agreedRate, brokerageNumber, expenses) and transaction types. Covers prerequisites and bulk feature. Lacks description of pagination parameters but is otherwise complete.

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

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

Schema has 0% description coverage. Description explains investment_id and investment_ids ('Bulk support') but does not describe page and page_size. With 4 parameters, it partially compensates for the low coverage but leaves gaps.

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

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

The description uses a specific verb ('Returns') and clearly identifies the resource ('movement history for a specific investment position'). It lists transaction types (BUY, SELL, TAX, etc.) and data fields, distinguishing it from sibling tools like openfinance_list_investments (positions) and openfinance_list_transactions (regular transactions).

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

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

Provides clear usage context: 'Use after openfinance_list_investments to get the investment_id.' Mentions bulk support with investment_ids. Does not explicitly state when not to use or compare with all alternatives, but the context is adequate for an agent.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds valuable context: sequential connection queries with rate-limit spacing and per-connection return structure (`{ results, errors }`). This goes beyond 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 concise (4 sentences) with a logical structure: purpose and endpoint, parameter usage, omission effect, return format. Every sentence adds value with no redundancy or 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?

Despite no output schema and a single optional parameter, the description is self-contained: it explains operation, parameter semantics, return structure, and rate-limit behavior. It addresses all needed information for an AI agent to correctly invoke the tool.

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

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

The input schema has 0% coverage (no descriptions), but the description fully explains the `items` parameter: it's an array of connection selectors (item_id uuid, connector_id, or connector_name), and omitting it lists all banks. This adds essential meaning that the schema lacks.

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 lists loan contracts per bank connection, specifying the endpoint (GET /loans). It distinguishes from siblings like openfinance_get_loan_detail by emphasizing multi-connection listing, making its purpose specific and unambiguous.

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

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

The description explains two usage modes: with `items` for specific connections or omitted for all banks. While it provides clear guidance on how to use the tool, it does not explicitly mention when not to use it or suggest alternatives like openfinance_get_loan_detail for individual loan details.

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?

With readOnlyHint, idempotentHint, and destructiveHint set, the safety profile is already clear, but the description adds substantial behavioral context: auto-pagination vs manual pagination behavior, scheduled rows ordered at the top, per-connector PENDING variance, error-return shape, provider_incident blocks, and differences across detail modes. This goes well beyond what annotations alone 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 far too long and repetitive. The billId warning appears twice, once in the opening and once under detail:'rich', and the pagination explanation is delivered in a dense wall of text rather than being front-loaded. While the content is valuable, the lack of organization and redundancy makes this harder for an agent to consume than necessary.

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

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

Despite having no output schema, the description covers nearly everything required for correct invocation: date filters, pagination behavior, search filtering, credit-card caveats, account-echo validation incident handling, bulk access, and fallback diagnostics for zero results. Given the complexity of 8 parameters and a no-output-schema context, the description 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?

Schema description coverage is 0%, so the description carries the full burden for all 8 parameters. It clearly explains from/to as ISO YYYY-MM-DD filters, search_queries as case-insensitive OR-matching, the exact semantics of page/page_size in both default and manual modes, and the compact/rich/raw detail tradeoffs. All parameters are given operational meaning beyond the schema listing.

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

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

The description opens with a specific verb and resource: 'Returns transactions for a bank account (BANK or CREDIT type).' It further distinguishes this tool by explicitly calling it the ONLY way to get itemized credit card transactions, which clearly differentiates it from siblings like openfinance_list_credit_card_bills and openfinance_list_transactions_by_item.

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

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

Usage guidance is explicit and thorough. It names openfinance_list_credit_card_bills as the correct alternative for standardized open-bill totals, openfinance_list_accounts for statement dates, and openfinance_get_item_status when results seem stale. The description even warns against using transaction summation over billId and advises narrowing date ranges when truncated:true is returned.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds critical behavioral traits: truncation at 5000/account with truncated:true flag, and a provider_incident block when the Open Finance provider has an open incident affecting a connected bank, noting that data may be incomplete and reconnecting does not fix it. 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 quite long but well-organized and information-dense. Every sentence adds value. A slightly more front-loaded summary could improve conciseness, but the structure is logical and not wasteful. The length is justified by the complexity of the tool.

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 9 parameters, no output schema, and complex behavior (truncation, provider incidents), the description is complete. It explains all parameters, usage patterns, and edge cases. An agent can correctly select and invoke the tool based on this description alone.

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 fully compensates. It explains each parameter: item accepts connector_id/connector_name/item_id; from/to are ISO dates; granularity: 'monthly' vs 'raw' with behavior differences; detail: 'compact', 'rich', 'raw' with enrichment details; type filters BANK or CREDIT; top_n implied as 'largest N'; item_ids for batch. All 9 parameters are covered semantically.

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 does consolidated cash-flow analysis for a whole bank connection in one call, using specific verbs like 'analyze', 'resolves', 'fans out'. It distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_accounts by explicitly noting that no prior account listing is needed.

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 when to use this tool vs alternatives: 'you do NOT need to call openfinance_list_accounts first'. It also provides guidance on granularity (monthly default, raw for itemized rows) and detail options, plus context for specific use cases like 'análise anual/mensal'. Bulk support via item_ids is mentioned.

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

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

Annotations provide readOnlyHint, idempotentHint, destructiveHint. Description adds that it checks a public status page (live), and returns specific incident data affecting connected banks. 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?

Description is detailed but front-loaded with core purpose. All sentences are useful; could be slightly shorter but remains clear.

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

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

Given zero parameters and no output schema, description fully explains return structure and use case. Annotations cover safety. Complete for a read-only status check.

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

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

Input schema has 0 parameters (100% coverage). With no params, baseline is 4. Description correctly omits parameter details.

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

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

Description states it checks LIVE operational status of the Open Finance provider, distinguishing it from openfinance_get_item_status. It clearly lists return fields (global indicator, degraded components, incidents, your_banks_affected).

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/stale despite UPDATED connection, or to differentiate provider-side issue from connection problem. Mentions sibling tool for contrast.

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 readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds behavioral details: returns connect_url, honors user plan, handles caveats, and never dumps full 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 dense and informative, front-loading purpose and output. It could be slightly more concise, but every sentence adds value and the structure is logical. 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?

Given no output schema, the description adequately explains return fields (id, access, audience, connections, accounts, connect_url) and behaviors (plan, caveat). Minor omissions: no explicit mention of empty result handling, but overall complete for a search 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 fully explains both parameters: keywords (required for search, with example) and include_accounts (adds accounts to returned data). The description compensates completely for the missing schema descriptions.

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

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

The description clearly states the tool searches bank connectors by name, specifying the action ('searches'), resource ('bank connectors'), and parameters (keywords). It details the returned fields and distinguishes itself from sibling tools like 'connect' and 'marketplace' by positioning itself as a preliminary search step.

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 to call before connecting, explains when to surface caveat warnings, and clarifies that keywords are required and returns a hint otherwise. It also mentions plan implications (PF vs PJ), giving clear guidance on usage 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?

Discloses that recategorizing teaches Pluggy by creating a Category Rule, which goes beyond annotations. Annotations are minimal and consistent; 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 detailed but efficiently structured: front-loads the action, then explains side effects and response format. Could be slightly shorter, 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?

Despite no output schema, the description includes the response shape and explains batch semantics (per-item errors don't fail the batch). Complete for a mutation tool.

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

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

The schema has 0% coverage, so the description must compensate. It explains the required 'items' array structure with { transaction_id, category_id } and specifies where to obtain each ID from other 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 'corrects the category of one or more transactions', specifies the HTTP method and endpoint (PATCH /transactions/:id), and distinguishes from siblings by referencing how to obtain transaction_id and category_id from other 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?

Explicitly describes when to use (fix miscategorized transactions) and explains the side effect of creating a Category Rule for future similar transactions. Also covers batch error handling.

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 the tool is idempotent and non-destructive. The description adds the behavioral detail that the conversation array is needed for reproduction, which is useful 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 two sentences long, front-loaded with the purpose, and contains no superfluous words. Every sentence serves a distinct role.

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 with no output schema. The description covers the main usage and one key parameter behavior. However, it lacks details on the expected format of the conversation parameter (stringified JSON) and the context parameter, and does not mention the response behavior.

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

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

With schema description coverage at 0%, the description must compensate. It explains the purpose of the 'conversation' parameter ('include ... for reproduction') but does not add meaning for 'context' or 'message'. This is partial compensation but not comprehensive.

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

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

The description clearly states the tool's purpose: reporting bugs, missing features, or sending feedback. It uses specific verbs and resources and distinguishes itself from sibling tools (e.g., openfinance tools) which are primarily financial operations.

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

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

The description implies when to use (when reporting issues or feedback) but does not explicitly state when not to use or provide alternatives. No exclusions or comparative guidance is offered.

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, so the description carries a low burden. It adds context about the specific version information shown, but does not disclose additional behavioral traits beyond what annotations provide.

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

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

The description is a single, front-loaded sentence with no wasted words. Every word adds value.

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

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

Given the tool has no parameters, no output schema, and strong annotations, the description is sufficient. It could briefly mention the return format (e.g., strings), but it's not necessary 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?

There are zero parameters, and schema description coverage is 100%. The description need not add parameter information; the absence of parameters is well-handled.

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

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

The description uses a specific verb ('Show') and clearly identifies the resources ('MCP platform and adapter versions'). It effectively distinguishes this tool from all siblings, 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 implies usage for checking versions, but does not provide explicit when-to-use or when-not-to-use guidance. No alternatives are mentioned, but given the uniqueness of this tool, the omission is minor.

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, establishing the safety profile. The description adds context about what data is returned but discloses no additional behavioral traits such as rate limits, authentication requirements, or side-effect warnings. This is adequate for a simple read-only tool, but not particularly rich.

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, front-loaded sentence that efficiently enumerates the key output categories without redundancy. Every clause adds value, and there is no wasted wording.

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 status tool, the description is sufficiently complete. It explains what the toolkit state includes and implies the tool is for informational purposes. No output schema exists, but the enumerated return categories cover the necessary 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 tool accepts zero parameters, and the input schema is trivially complete (100% coverage). With no parameters to document, the baseline is 4, and the description does not need to compensate for any schema gaps.

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

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

The description uses a specific verb ('Returns') and clearly defines the resource ('current toolkit state') with enumerated details (installed MCPs, connection status, connected accounts, catalog tool counts). This makes the tool's purpose unmistakable and distinguishes it from sibling tools like authenticate or connect, which perform actions rather than report state.

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 the tool is for checking toolkit status, but it does not explicitly state when to use it versus alternatives or mention any exclusions. It provides clear context about the output, but no usage guidance or comparisons to other tools, so it falls at the 'implied usage' level.

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