Monte Bravo MCP

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

The description explains the behavioral difference between calling with and without the token, and notes that config-based tokens are permanent while session tokens are not. Annotations indicate idempotent, which aligns. No contradictions, and the description adds context beyond the annotations about the two login modes.

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

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

The description is three sentences, each presenting a distinct and necessary piece of information: the context, the best practice, and the alternative usage. No fluff, well-structured.

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

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

Given the tool is simple (one optional parameter, no output schema), the description sufficiently covers the purpose and usage. It could mention error cases or the link format, but it is complete enough for an agent to decide whether and how to invoke it. Sibling tools do not overlap significantly.

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 no description for the 'token' parameter (0% coverage). The description compensates fully by explaining that 'token' is a JWT access token and that omitting it returns a login link. This is clear and actionable.

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

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

The description clearly states the tool is for authentication ('log in') for MCP.AI IDE agents. It specifies the exact usage: obtaining a token from the browser and either adding it to config for permanent access or passing it as a JWT for session-only login. This distinguishes it from siblings like 'connect' or 'marketplace'.

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

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

The description provides explicit guidance on when to use each mode (config vs. session token vs. no arguments to get link). It implies when to use by outlining the best practices, but does not explicitly exclude alternative tools or scenarios.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds useful behavioral context beyond annotations, such as returning authenticated:true with empty pending[] when connected, or connect_url when credentials are missing.

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

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

The description is concise, with two sentences that are clear and to the point. No unnecessary information.

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

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

Given no output schema, the description explains the two main states of the tool. While it could detail the exact response fields, it provides enough context for a simple status check 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?

There are no parameters, and schema description coverage is 100%. The description does not need to explain parameters, so it is satisfactory.

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

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

The description clearly states it returns connection status and URLs, with specific behavior for different states. While the name 'connect' is generic, the description clarifies its purpose. However, it could better differentiate from the sibling tool 'authenticate' which likely deals with 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 context on when to use the tool by describing the two possible states (all providers connected vs credentials missing). However, it does not explicitly state when not to use it or mention alternative tools.

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

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

The description discloses important behavioral traits beyond annotations: invoke works even when the MCP is not installed, credential/logins return a connect link, paid tools with empty wallet return a checkout/top-up link, and install makes an MCP permanent. It also notes that writes (install/uninstall/subscribe/cancel and the one-off install behind invoke) require owner/admin. Annotations provide readOnlyHint=false and destructiveHint=false, which do not contradict the description; the description adds meaningful operational 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 a single dense paragraph with several long, run-on sentences and many embedded clauses. It front-loads the core purpose and flow well, but the prompt-library section is tacked on at the end and the whole text is harder to parse than it should be. Some bolding or bullet structure would have earned a higher score; every sentence does carry information, but the overall structure lacks conciseness.

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

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

Given the tool's high complexity (23 parameters, 14 actions, no output schema), the description is quite complete: it explains the main flows, write permissions, authentication/link behavior, and prompt-library operations. It does not describe the exact result format of search/list_tools or error conditions, but for a broad dispatcher tool it provides enough context for an agent to choose and invoke the appropriate action.

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%, and no parameters have descriptions. The description compensates by mapping key action values to their semantics: search, describe, invoke with 'tool_id', install, subscribe/cancel, report_bug, request_mcp, and the prompt-related actions. It explains important argument roles (tool_id, prompt_vars, prompt_slug). However, it does not elaborate on many secondary parameters (limit, tier_slug, cancel_reason, conversation, etc.), so it is not a complete substitute for schema-level parameter 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 opens with a strong, specific statement: 'The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' It clearly names the resource and the core verbs (search, describe, invoke, install, list_tools, subscribe/cancel, prompts). It distinguishes itself from sibling openfinance tools and utility tools by establishing itself as the central MCP catalog and execution layer.

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 usage guidance: 'Core flow: action=search discovers MCPs by intent → describe returns one MCP's full profile ... → invoke RUNS that tool.' It also contrasts invoke vs install ('prefer invoke for a single/occasional use'), names list_tools for 'what is callable right now', assigns billing actions to subscribe/cancel, and states that writes require workspace owner/admin. This is far beyond generic guidance.

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

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

Annotations declare destructiveHint=true. The description adds useful context: consent revocation, data deletion, unavailability of data, and a return value for reconnection. 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?

Two concise sentences front-loaded with the main action. Every sentence adds value with no redundancy.

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

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

Given the destructive action, single parameter, no output schema, and sufficient annotations, the description covers the key behavioral aspects. It could improve by documenting the parameter, but overall it is reasonably 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 coverage is 0% and the description does not clarify the 'item' parameter (e.g., bank ID or name). It only mentions 'specific bank', which leaves the parameter meaning ambiguous.

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

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

The description clearly states the action: revokes consent and deletes connection data for a specific bank. It uses specific verbs and resources, and distinguishes from sibling tools like connect or list_connections by its destructive nature.

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 disconnecting a bank and notes the consequence (data no longer available) and return (reconnection URL). However, it does not explicitly state when to use versus alternatives like openfinance_list_connections or when not to use.

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

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

Annotations already indicate mutation (readOnlyHint=false). Description adds details: waits up to ~60s, polls until item stops updating, returns reconnect_url for MFA scenarios, and confirms no disconnect/reconnect needed.

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

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

Single dense paragraph that effectively front-loads key action. Could be improved with structure (e.g., bullet points), but no waste and covers all necessary details.

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?

Comprehensive for 2-param tool without output schema. Details return structure (results, errors), status fields, timed_out handling, and MFA reconnection flow. References sibling tool for continued polling.

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

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

Schema coverage 0%, but description compensates fully: explains wait as boolean for sync mode, items as array of selectors (item_id, connector_id, etc.), and omitting syncs all linked banks.

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 'forces bank to re-sync connections' with specific verb-resource. Distinguishes from sibling openfinance_get_item_status by explaining that it pulls fresh data without 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?

Explicitly says when to use (stale balance/transaction list) and provides usage variants: omit items to sync all, set wait=false for fire-and-forget. References sibling tool for polling 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?

Beyond annotations (readOnlyHint, idempotentHint), the description richly discloses behavior: snapshot semantics tied to last upstream sync, specific error types (BALANCE_FETCH_ERROR, BALANCE_CONSENT_ERROR) with structured warnings instead of throwing, and degradation behavior on upstream 5xx or non-Open Finance connectors. This is substantial value added over structured metadata.

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 longer than average but every sentence earns its place, covering core function, snapshot caveat, sync alternative, parameter format, and error handling. The key purpose is front-loaded. Slight redundancy in repeating balance/sync concepts, but overall well-organized.

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-related behavior: row timestamps (updateDateTime/updatedAt), structured warning fields, error conditions, and recovery steps. For a simple 1-parameter read tool, this fully covers what an agent needs to invoke it correctly.

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

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

With 0% schema description coverage, the description carries the full burden. It adds critical semantics by specifying that account_ids must be passed as an array (1-50), which exceeds the schema's bare 'array of strings' definition. It could further clarify ID format, but the range and type guidance is meaningful.

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

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

The description states a specific verb and resource ('Returns the latest available balance per account id') and explicitly distinguishes it from siblings by clarifying it is a snapshot rather than a live read, contrasting with openfinance_force_sync for refreshing data. This differentiates it clearly from related tools like openfinance_list_transactions.

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

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

The description gives clear usage context: it explains when the snapshot may be stale, directs users to openfinance_force_sync when data is not fresh, and references openfinance_list_transactions for cross-checking. However, it does not explicitly state 'when not to use this tool' or provide exclusion conditions.

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 destructiveHint=false. The description adds important behavioral context: batch response shape {results, errors}, and a provider_incident block that can make credit limits/balances unreliable. This adds value 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 three sentences with zero waste. First sentence states purpose, second gives parameter guidance, third warns about data reliability. Information is front-loaded and every sentence serves a distinct 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?

Given the single parameter, clear annotations, and no output schema, the description covers the core functionality and a critical caveat. It does not detail the full return structure, but the warning about provider_incident is essential. Adequate 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 has one parameter with 0% description coverage. The description explains it's an array of 1-50 items and implies they are account IDs (per id). It adds the batch response shape. However, it does not specify the format or type of the strings, leaving some ambiguity. Still, it compensates partially.

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

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

The description clearly states the tool returns full account objects with extended creditData per id. It specifies the endpoint and distinguishes from list accounts by highlighting detailed data. The verb 'Returns' and resource 'account objects' are specific.

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 to pass account_ids as an array (1-50) and describes batch shape. It provides a critical usage warning about provider_incident blocks. However, it does not explicitly state when to use this tool over siblings like openfinance_list_accounts, though the detail level is implied.

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?

While annotations already say readOnlyHint true and idempotentHint true, the description adds crucial behavioral context: transactions are opt-in and require account_id on case, transactions_basis can be bill_id or date_window with confidence, automatic account resolution may fail per-bill, and totalAmount is authoritative over transaction sums. This goes well beyond the annotations.

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

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

The description is longer and dense, but each sentence has practical value; nothing is mere filler. It could be lightly tightened to reduce parenthetical verbal detours, so it loses one point for structure flowuality.

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 and a richer 4-parameter contract, the description takes on the full burden and succeeds: it covers response fields, opt-in behavior, account resolution failure handling, batch id use, and limitations. An agent has enough to call and interpret the result 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%, but the description independently explains all four parameters: there are bill IDs, account_id is optional but needed as include_transactions, include_transactions toggles enriched rows, and transactions_full compact/raw/rich are described by content/truncation behavior. It even warns about compact truncation limitations.

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 and resource: 'Returns bill-level detail for one or more credit card bills by id' (GET /bills/:id). It lists the key returned fields (dueDate, billClosingDate, totalAmount, payments[]) and distinguishes itself from the sibling list tool by emphasizing detail-by-id.

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

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

Explicitly routes the agent to alternatives: use openfinance_list_credit_card_bills to discover ids, prefer openfinance_list_transactions when full itemized transactions are needed, and use openfinance_list_credit_card_bills for paid status. It also warns about payments[] being misread as payment 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?

The description adds context beyond annotations: it discloses the reconnect_url behavior, possible status values (UPDATED, UPDATING, LOGIN_ERROR), and that it doesn't consume a connection slot. Annotations already indicate read-only, idempotent, non-destructive, consistent with 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?

The description is concise, front-loaded with the main purpose, and each sentence adds value. 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 covers return fields, multiple usage modes, and reconnect URL. Could mention behavior when both 'item' and 'item_ids' are provided, but overall sufficient for a read-only tool with good annotations.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It explains the effect of omitting 'item' vs passing it, and mentions bulk via 'item_ids'. However, it does not differentiate 'item' from 'item_id', nor specify constraints like data types beyond schema. Still adds substantial 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 the tool returns the current status of a bank connection, listing specific fields (status, executionStatus, connector metadata, reconnect_url). It differentiates from sibling tools like openfinance_list_connections by focusing on status and providing a reconnect mechanism.

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 omit or include the 'item' parameter for all vs single bank, and mentions bulk support with 'item_ids'. It does not explicitly contrast with alternatives like openfinance_list_connections or openfinance_force_sync, but the usage patterns are clear.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds value by detailing the batch response shape ({ results, errors }) and the parameter constraint (array of 1-50). 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 a single paragraph that fronts the core purpose and then adds details; while thorough, it could be slightly more concise (e.g., reducing field listing). However, every sentence 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?

Given no output schema and only one parameter, the description provides sufficient completeness: it enumerates key fields, specifies parameter constraints, explains the batch response format, and includes a usage workflow reference. No gaps that would hinder an AI 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?

The input schema has 0% description coverage; the description fully compensates by specifying that loan_ids is an array of strings limited to 1-50 items, and explains the expected batch response shape, adding crucial context for correct invocation.

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

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

The description clearly states it returns full loan contract detail by ID, enumerating specific fields (interestRates, amortizationScheduled, etc.), and distinguishes from the sibling openfinance_list_loans by indicating this is a deep-dive tool for specific contracts.

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

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

Explicitly advises to use after openfinance_list_loans, providing a clear workflow. Specifies the batch shape and array size limit (1-50), but does not mention when not to use or alternative tools for other data.

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 readOnly/idempotent annotations, the description discloses connector-dependent balance semantics, `balance_notice` meaning, stale/phantom `bankData` fields after connection creation, `provider_incident` reliability caveats, and `identity_notice` consent-holder deduplication instructions. These are actionable warnings that materially change how an agent should present results.

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 core purpose and each paragraph covers a distinct, important caveat. It is long, but the length is mostly justified by the tool's complexity and the lack of an output schema; a few warnings could be compressed.

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 tool, the description covers returned fields, parameter behavior, cross-tool routing, and edge cases such as provider incidents, stale balances, and duplicate accounts. An agent has enough information to select and invoke this tool correctly, including what not to do with the results.

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 coverage, the description compensates by explaining the semantics of `item` (present = single bank, omitted = all banks), `item_ids` (bulk execution), and BANK/CREDIT as account categories. It falls slightly short by never explicitly stating that `type` filters the response and by not explaining the input `item_id` parameter or its relationship to `item`.

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 opening sentence names a specific verb ('Returns'), a concrete resource ('accounts for a bank connection'), and the two account categories (BANK/CREDIT) with the fields returned. It also clarifies the brand/legal-entity naming distinction and differentiates single-bank vs all-banks scope, so an agent can distinguish it from list_transactions or get_accounts_detail.

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

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

The description gives explicit decision rules: omit `item` when the user asks for accounts/cards across banks, pass `item` to target one bank, and use openfinance_list_credit_card_bills for standardized open-bill amounts/total debt instead of treating `balance` as the bill. It also points to openfinance_force_sync to reconcile lagging derived fields.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. The description adds valuable context: caching for the session, single aggregated response, and no batch ids. This 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?

Every sentence is informative. Front-loaded with the main purpose, then details on fields, language, caching. No fluff or repetition.

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

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

Given zero parameters and no output schema, the description fully explains the response structure (fields, caching) and usage hint (language). Complete for a simple retrieval 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 no parameters (100% coverage). Description adds no parameter semantics, but baseline for zero parameters is 4. No missing information.

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

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

The description clearly states it returns Pluggy's transaction category taxonomy, mentioning caching and specific fields like id, description, descriptionTranslated, parentId, parentDescription. It also links the categoryId to another tool, but does not explicitly distinguish from siblings, though it is unique among them.

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 language preference (Portuguese for pt-BR users), but does not explicitly state when to use this tool versus alternatives. Since there is no direct sibling for categories, 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 and destructiveHint=false. The description adds valuable behavioral details about the reconnect_url (UPDATE mode, no slot consumption, no disconnection needed) and the add_connection_url, going beyond what annotations provide.

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

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

The description is somewhat lengthy (4 sentences) but each sentence provides essential information. It is front-loaded with the primary purpose and structured logically. Minor reduction could improve conciseness 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 parameterless list tool with annotations present, the description covers returned fields and special URL behaviors. It lacks details on pagination or empty results, but these are less critical for this simple tool. Overall, it is sufficiently 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 tool has zero parameters, so the baseline is 4. The description is not required to explain parameters, and it adds no parameter information, which is appropriate.

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

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

The description clearly states the tool 'Returns the saved bank connections' and lists specific fields (connector_id, item_id, bank name, etc.), distinguishing it from sibling tools that handle accounts, transactions, or other resources.

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 reconnect_url (re-authentication, MFA, LOGIN_ERROR, stale data) and its behavior, but does not explicitly state when to use the tool itself versus alternatives. The context is clear for a simple list operation.

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

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

Annotations only indicate readOnlyHint=true and idempotentHint=true. The description adds deep behavioral context: derived payment_status logic, open_bill derivation, connector asymmetry, and warning about bill grouping reliability. 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?

Very long description with multiple paragraphs. Front-loaded with purpose, but extensive details make it less concise. Every sentence adds value, but could be more structured.

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

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

Given complexity (5 params, no output schema), the description is extremely thorough: covers input, output structure, derived fields, edge cases, warnings. It is practically a mini-manual.

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 description must compensate. It thoroughly explains include_open_bill and account_ids (bulk). However, page and page_size parameters are not described, leaving some gap.

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

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

The description clearly states it returns CLOSED credit card bills for a CREDIT-type account, listing specific fields (dueDate, totalAmount, payments, etc.). It distinguishes itself from siblings like openfinance_get_credit_card_bill (singular) and openfinance_list_transactions.

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

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

Explicit guidelines: when to use include_open_bill, warnings about payment semantics and connector asymmetry, and advice against reconstructing bill totals from transactions. Also mentions alternative tool openfinance_list_transactions for itemized charges.

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 significant behavioral context: error handling (returns structure instead of throwing), data integrity checks via transaction history cross-referencing, and specific warnings. 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 detailed but well-structured with paragraphs for different aspects (purpose, error handling, data integrity). It is front-loaded with the main purpose. While somewhat lengthy, all sentences add value, so it's acceptable.

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

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

Given 6 parameters and no output schema, the description covers output behavior thoroughly, including error handling and data integrity. However, it lacks parameter explanations, which is a gap. Overall, it provides enough context for an agent to use the tool correctly in most scenarios.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains item_ids for bulk execution but does not clarify parameters like item, page, type, or page_size. This leaves the agent guessing about their meaning and usage.

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

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

The description explicitly states it returns investment portfolio data for a connection, listing specific asset types like FIIs, stocks, ETFs, etc., and details the fields included. This clearly distinguishes it from sibling tools such as openfinance_get_account_balance or openfinance_list_accounts.

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

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

The description provides guidance on bulk execution via item_ids and explains behavior when INVESTMENTS is not enabled. It also discusses data integrity warnings, telling the agent not to sum suspect_zeroed rows. However, it does not explicitly state when to avoid using this tool or compare directly with alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds transaction types, specific fields (expenses, agreedRate, etc.), and bulk behavior. 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 efficient paragraphs with no fluff. Front-loaded with main purpose, then usage hints. Every sentence adds value.

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

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

With annotations present, description provides usage context, return details, and bulk support. Lacks explanation of pagination parameters, but overall sufficient for a list 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% (no param descriptions). Description mentions investment_id and investment_ids, but omits page and page_size parameters entirely, leaving their semantics 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?

Description clearly states verb (returns), resource (movement history for investment position), and lists transaction types (BUY/SELL/TAX/INTEREST/AMORTIZATION/TRANSFER). Distinguishes from sibling openfinance_list_investments.

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

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

Explicitly advises to use after openfinance_list_investments to get investment_id, and mentions bulk support for investment_ids. Provides contextual ordering without excluding alternatives.

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

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

Annotations indicate read-only, non-destructive, idempotent. Description adds sequential query behavior and return format, providing valuable context beyond annotations.

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

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

Three sentences, front-loaded 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?

With no output schema, description includes return format. Covers all key behaviors for this one-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 'items' as connection selectors with types and usage, compensating completely.

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 'lists loan contracts per bank connection' with specific verb and resource. Distinguishes from siblings like openfinance_get_loan_detail.

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

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

Explains when to use 'items' parameter and when to omit for all banks. Mentions sequential queries and rate limiting. Could explicitly mention alternatives.

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

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

The description discloses many non-obvious behaviors absent from annotations and schema: date descending order with future-dated scheduled rows, auto-pagination up to 5000 items, truncation warnings, error response shape, provider_incident handling, per-connector variation in pending/posted coverage, and the meaning of billForecastDate. It does not contradict annotations, and the readOnlyHint is consistent with the described 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 very long and dense, but it is organized into focused sections (pagination, detail variants, scheduled rows, billing hints) and each paragraph delivers unique operational knowledge. There's some redundancy around credit card billId warnings, which prevents a perfect 5, but the overall density is justified for such a complex 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 takes on the responsibility of explaining return semantics: it covers the account echo block, scheduled_count and notice, truncated and warning, error response shape, provider_incident, and detail level variations. This is sufficient for an agent to not only call the tool but also correctly interpret and validate results.

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

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

Despite 0% schema description coverage, the description fully compensates by explaining all 8 parameters: from/to formats and semantics, page/page_size combined behavior with auto-pagination switch, detail enum values, search_queries case/accent-insensitive semantics, account_id vs account_ids for bulk, and default pagination. This is exemplary compensation for missing schema metadata.

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 clearly distinguishes this from sibling tools by explaining that it is the only way to get itemized credit card transactions and by explicitly comparing it to openfinance_list_credit_card_bills. The scope and resource are 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 extensive when-to-use vs alternative guidance: it directs users to openfinance_list_credit_card_bills for standardized open-bill totals, to openfinance_list_accounts for closing/due dates, and to openfinance_get_item_status for checking sync health when total is 0. It also explicitly warns against using billId to reconstruct bill totals, which prevents a common error. This is far beyond minimal guidance.

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

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

The description goes beyond annotations by disclosing truncation at 5000 transactions per account with a truncated flag, potential provider_incident block affecting data completeness, and bulk support via item_ids. Annotations only indicate read-only and idempotent, so this additional context is highly valuable.

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, starting with the main purpose, then parameter details, and ending with edge cases. It is slightly verbose with examples like 'análise anual/mensal', but every sentence adds value. A more concise version could omit some examples, but current length is justified by 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 9 parameters, no output schema, and many sibling tools, the description is remarkably complete. It covers what the tool does, how to use it, parameter formats and defaults, response contents (summary fields like por_mes, top_despesas), truncation behavior, and provider incidents. Without output schema, it provides sufficient detail 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?

With 0% schema description coverage, the description fully compensates by explaining every parameter: item (connector_id, connector_name, or item_id), from/to as ISO dates, granularity with default and raw option, type for BANK/CREDIT, detail levels (compact, rich, raw), top_n implied in top_despesas, and item_ids for batch. No formal param descriptions exist, so this is critical.

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 bank connection in one call, resolving accounts internally. It uses specific verb 'analyze' and resource 'connection transactions', and distinguishes itself from siblings like openfinance_list_transactions by explaining it avoids separate account listing.

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

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

The description explicitly says when to use this tool: for annual/monthly cash flow analysis, and explains that it eliminates the need for prior account listing. It also provides use case examples. However, it could more directly state when alternatives like openfinance_list_transactions are preferred (e.g., for per-account raw data), but the context is still clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description confirms it's a non-destructive read. It adds context that the tool queries a public status page and returns global indicator, degraded components, open incidents, and affected banks. This adds value beyond annotations but no deep behavioral surprises.

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

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

The description is two sentences: first states the core purpose, second provides usage guidance and details. No filler words, front-loaded with the main action, and each sentence earns its place. Very 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?

Given zero parameters and no output schema, the description covers the tool's purpose, use case, and return value details comprehensively. It does not mention rate limits or edge cases, but for a simple status-check tool, it is sufficiently 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 tool has zero parameters with 100% schema coverage (empty schema). The description compensates by listing all returned fields (global indicator, degraded components, incidents, your_banks_affected), which adds meaning beyond the schema. Per guidelines, baseline is 4 for 0 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 checks the LIVE operational status of the Open Finance provider's public status page. It distinguishes itself from sibling tool openfinance_get_item_status by specifying it checks provider health, not the user's connection. The verb 'Checks' and resource 'provider status' are 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?

Explicitly tells when to use: 'whenever data looks incomplete or stale even though a connection shows UPDATED'. It explains the tool reveals upstream outages and helps differentiate provider-side problems from connection issues. While it doesn't explicitly state when not to use, the context is clear enough for the agent.

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

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

Annotations already indicate readOnly, idempotent, non-destructive. Description adds significant behavioral info: caveat warnings, plan-based visibility, never dumps catalog, and return contents.

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?

Packed with necessary information but slightly verbose. Front-loaded with main purpose. Each sentence adds value, though some details could be streamlined.

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

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

With no output schema, description details the return fields (connector id, access, audience, connections, accounts, connect_url) and special behaviors. Lacks explicit output format but sufficient 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 has 0% parameter descriptions, so description compensates by explaining keywords usage with examples and include_accounts purpose. Minor discrepancy: schema marks keywords optional, description says required.

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 searches bank connectors by name and returns detailed match info including a connect_url. Differentiates from siblings like 'connect' by being the pre-connection 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' and notes that keywords is required, with a fallback hint. Lacks explicit exclusions or alternatives, but context makes usage straightforward.

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=false, destructiveHint=false), the description discloses that recategorizing creates a Category Rule for future similar transactions, explains batch error handling (per-item errors do not fail the whole batch), and specifies the return shape. This adds significant value.

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 verbose but front-loaded with the main action. Every sentence adds value, covering side effects, batch behavior, and error handling. A minor trim could improve conciseness.

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

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

Given the complexity (side effect, batch processing, error handling) and lack of output schema, the description is complete. It explains the return shape, error list, and the learning mechanism, leaving no critical 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 fully explains the 'items' parameter as an array of { transaction_id, category_id }, and tells where to get these IDs (from openfinance_list_transactions and openfinance_list_categories). This compensates for the lack of schema descriptions.

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

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

The description states 'Corrects the category of one or more transactions (PATCH /transactions/:id)', which uses a specific verb and resource. It clearly distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_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 explicitly says 'use this to fix miscategorized transactions and improve categorization accuracy going forward', providing clear when-to-use guidance. It does not explicitly state when not to use or name alternative tools, 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 provide idempotentHint=true; description adds reproduction context but no other behavioral traits beyond write intent. 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?

Two sentences, no wasted words, first sentence states purpose, second provides guideline.

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; description lacks return value explanation and full parameter guidance. Adequate for a simple feedback tool but not complete.

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

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

With 0% schema description coverage, description only clarifies 'conversation' parameter purpose but not 'message' (required) or 'context'. Insufficient for 3 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 the tool reports bugs, missing features, or feedback, distinguishing it from sibling tools focused on Open Finance or authentication.

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

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

Explicitly advises including the conversation array for reproduction, though does not specify when to use vs alternatives, which are absent.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false; description adds no behavioral context beyond confirming it's a read operation.

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

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

Single sentence with no wasted words, clearly front-loaded with the action and result.

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

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

For a zero-parameter, no-output-schema tool with rich annotations, the description is complete and 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?

No parameters exist, so schema coverage is 100%; description adds meaning by specifying what versions are shown.

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

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

The description clearly states the tool shows 'MCP platform and adapter versions', with a specific verb 'Show' and resource, distinguishing it from sibling tools like 'toolkit_info'.

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 is self-evident for a version display tool; no alternatives or exclusions needed, though explicit guidance is minimal.

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 safety profile is covered. The description adds value by detailing the exact information returned (installed MCPs, statuses, accounts, tool counts), which goes beyond the annotations and helps the agent predict the output.

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

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

The description is a single, well-structured sentence that front-loads the main verb and resource, then lists the key components. Every part earns its place with no redundant language.

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 no-parameter info tool with no output schema, the description clearly enumerates the types of data returned (MCPs, status, accounts, tool counts), which gives the agent a solid expectation. It could add more detail about the return format or edge cases, but the current level is sufficient for the tool's simplicity.

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

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

The tool has zero parameters, and schema coverage is 100% (trivially). The description doesn't need to explain parameters, and with no params to clarify, a 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?

The description uses a specific verb 'Returns' and clearly identifies the resource as 'the current toolkit state'. It enumerates the exact contents (installed MCPs, connection status, accounts, catalog tool counts), which distinguishes it from sibling tools that perform actions or retrieve domain-specific 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 this is the go-to tool for a system-level overview of MCPs and connections, providing clear context. It doesn't explicitly state when not to use it or name alternatives, but the sibling list shows other tools are specialized for finance operations, making the usage context clear enough.

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