Méliuz MCP

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

Annotations show idempotentHint=true and destructiveHint=false; description adds context that token in header is non-expiring and that session-time token is temporary. No contradiction.

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

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

Description is front-loaded with purpose and concise, though slightly long due to multiple instructions. Every sentence adds value, with minimal 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?

With no output schema and no required parameters, the description covers all needed context: link generation, token usage, and permanent vs session setup, making it fully 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%, but the description explains the 'token' parameter as an optional JWT for session login. It adds meaning beyond the schema's bare type definition.

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 the verb 'authenticate' and clearly identifies the resource as a session or token. It distinguishes itself from sibling tools like 'connect' by focusing on authentication steps.

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 provides two usage paths: permanent config via header or session login via token parameter. Also instructs calling with no args to get the link, covering when and how to use each option.

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 false. The description adds value by explaining the two distinct return states (authenticated:true vs connect_url), which is beyond the annotations.

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

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

Two sentences, front-loaded with the core purpose, and every word is informative. No wasted verbiage.

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

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

Without an output schema, the description carries the full burden of explaining return values. It covers both cases adequately. A more complete description could mention pagination or error behavior, but for a simple status tool this is sufficient.

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

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

No parameters exist, so baseline is 4. The description adds meaning by explaining what the tool returns in different scenarios, which is helpful for understanding the output.

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 detail about different states (all connected vs missing credentials). It is a specific verb+resource with no ambiguity.

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

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

The description implies usage for checking connection status, but does not explicitly state when to use this tool versus siblings like 'authenticate' or the various 'openfinance' tools. No alternative guidance is given.

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 important behaviors beyond annotations: invoke works even when the MCP is not installed and runs one-off without bloating the toolkit; returns connect links for auth and checkout/top-up links for payments; writes require workspace owner/admin. The description also clarifies that install makes tools permanent. No contradiction with annotations (readOnlyHint=false and its write operations align).

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 dense; every sentence adds value. It front-loads the core purpose and flow, then covers edge cases and auxiliary actions. A more structured layout (e.g., bullet points) would improve readability, but the content is well-organized and free of 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?

The description covers nearly all actions (search, describe, invoke, install, uninstall, subscribe, cancel, report_bug, request_mcp, list_tools, search_prompts, get_prompt, publish_prompt) and critical behavioral notes about auth, payment, and permanent vs ephemeral installation. However, it omits the 'resume' action and lacks detailed parameter semantics, leaving some gaps for correct invocation.

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

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

The description explains the action parameter (search, describe, invoke, etc.), tool_id, arguments, and prompt-related fields, but it does not cover many other parameters such as limit, query, immediate, tier_slug, cancel_reason, etc. Given 0% schema coverage, a tool with 23 parameters needs more parameter-level detail than this provides, though the core action/flow is well 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 the marketplace as the in-platform catalog of every MCP/tool and the way to run them, with a specific core flow (search → describe → invoke). It distinguishes itself from sibling tools (mostly openfinance and auth tools) by being a cross-cutting platform for discovering and executing MCPs.

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 guidance on when to use invoke (single/occasional use) vs install (permanent), and explains the core flow for capability requests. It also gives context for subscribe/cancel, report_bug, request_mcp, and prompt library actions, making the tool's intended usage clear relative to 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 provide destructiveHint=true. The description adds that data is deleted and no longer available, and mentions a return value for reconnection. 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?

Three concise sentences, each adding value without redundancy. Front-loaded with action, then consequences, then return 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 destructive action with one parameter, the description covers the outcome and return value. However, missing parameter definition and no output schema make it slightly incomplete.

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 single parameter 'item' has no schema description (0% coverage) and the description does not clarify what 'item' represents (e.g., bank ID, connection ID). This leaves ambiguity for the agent.

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

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

The description clearly states the tool revokes consent and deletes connection data for a specific bank, with a clear verb ('Revokes') and resource ('Open Finance consent for a specific bank'). It distinguishes from siblings like 'connect' or 'openfinance_list_connections'.

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

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

The description implicitly tells when to use (to disconnect a bank) but lacks explicit when-not or alternatives. It doesn't mention prerequisites like verifying the connection first via '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?

Annotations show destructiveHint=false and readOnlyHint=false, consistent with a mutating but non-destructive sync. Description adds details: waits up to 60s, polls, returns status fields, and handles auth issues with reconnect_url. No contradiction.

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

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

Description is thorough but somewhat lengthy. However, it is front-loaded with action and key details, and every sentence adds value. Could be slightly trimmed.

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, description fully explains return values: results, errors, status, executionStatus, lastUpdatedAt, synced, needs_action, reconnect_url, timed_out. Covers all edge cases and next steps.

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

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

Schema coverage is 0%, so description fully explains both parameters. 'items' is described as array of selectors (item_id, connector_id, etc.) and omitting syncs all. 'wait' is explained as boolean for fire-and-forget.

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

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

Description clearly states it forces a synchronous re-sync of connections. It uses specific verb 'forces' and resource 'bank connections', distinguishing from sibling tools like openfinance_get_item_status which only checks status.

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

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

Explicitly advises when to use (stale balance/transactions) and what not to do (no disconnect/reconnect). Also mentions alternative openfinance_get_item_status for timed_out cases.

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

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

The description adds significant behavioral context beyond annotations: it warns about BALANCE_FETCH_ERROR for CREDIT accounts, degradation to last-synced balance when upstream is unavailable, and provides the response shape. This aligns with annotations (readOnlyHint, idempotentHint, destructiveHint) and adds detail.

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

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

The description is concise yet packed with essential information: endpoint, parameter constraints, error handling, degradation logic, and response format. Every sentence adds value without redundancy.

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

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

Despite lacking an output schema, the description explains the response shape and covers various edge cases (credit accounts, upstream failures). It is complete for a real-time balance tool with complex banking API 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?

The description adds meaning to the 'account_ids' parameter by specifying it should be an array of 1-50 items, which is beyond the schema's type constraint. However, it doesn't describe the format of each string (e.g., account ID format). For a schema with 0% coverage, this is helpful.

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 'Returns real-time balance payload per account id' and specifies the endpoint. It distinguishes from siblings by focusing on balance retrieval for a single account, while siblings like openfinance_list_accounts list accounts and openfinance_get_accounts_detail provide 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 provides explicit usage guidance: 'Pass `account_ids` as an array (1–50).' It also describes behavior for CREDIT accounts and upstream failures, helping the agent decide when to use it. However, it does not explicitly compare to alternatives or state 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 mark the tool as readOnly, idempotent, and non-destructive. The description adds critical behavioral context: the batch response shape { results, errors }, and the provider_incident block indicating unreliable credit limits/balances during provider incidents. This goes beyond annotations and warns against presenting values as real, which is valuable for safe agent use.

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, each sentence adds essential information: the first defines the tool's output, the second explains usage and a critical caveat. No redundant or filler content. It is front-loaded with the primary 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 tool has one parameter, no output schema, and annotations covering safety, the description provides complete context: it explains the batch shape, the provider incident hazard, and the parameter limit. It is sufficient for an agent to use the tool correctly without additional external knowledge.

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

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

The schema has 0% description coverage for the only parameter, so the description compensates by specifying the array constraint (1–50 items). It does not describe the string format (presumably account IDs), but the limit is a meaningful addition. The description adds enough value to raise the score above the baseline 3.

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 account objects with extended creditData per ID, referencing GET /accounts/:id. It distinguishes itself from sibling tools like openfinance_list_accounts (list) and openfinance_get_account_balance (balance only) by specifying the scope and including the batch shape.

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 instructs to pass account_ids as an array (1–50) and warns about provider incidents affecting data reliability. However, it does not explicitly state when to use this tool versus alternatives (e.g., for detailed credit data vs. basic balance). The usage context is clear but lacks explicit when-not-to-use guidance.

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

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

Discloses several behavioral traits beyond annotations: does not return individual transactions, payments[] may reflect previous bill's payment, Pluggy does not return paid/status field, and billId hint is sparse. Aligns with readOnlyHint and destructiveHint 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?

Well-structured and front-loaded with main purpose, but slightly lengthy. Every sentence adds value, though minor tightening possible.

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, description fully explains return shape (financeCharges, payments with fields), batch {results, errors} format, and caveats about interpreting payments. Complete 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?

With schema description coverage at 0%, the description compensates by explaining bill_ids is an array and recommending discovery via openfinance_list_credit_card_bills. Could mention array format explicitly but is effective.

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 bill-level detail for credit card bills by ID, explicitly listing returned fields (financeCharges, payments) and distinguishing from sibling tools like openfinance_list_transactions and openfinance_list_credit_card_bills.

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

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

Provides explicit guidance: use this tool for bill-level detail, use openfinance_list_transactions for itemized transactions, and use openfinance_list_credit_card_bills first to discover bill IDs. Also explains when not to rely on payments[] for paid status.

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

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

Annotations already indicate idempotentHint=true, readOnlyHint=true, and destructiveHint=false. The description adds valuable behavioral details: the reconnect_url reopens the widget in UPDATE mode without disconnecting or consuming a slot, and it mentions bulk support. 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 two sentences: first sentence packs the core functionality with return values and special behavior (reconnect_url), second sentence covers bulk usage. No unnecessary words, front-loaded with key information. Highly 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 exists, but the description details the return fields (status, executionStatus, connector metadata, reconnect_url) and the bulk response shape ({ count, items }). For a read-only status tool, this provides sufficient context to use correctly. Could mention pagination or error handling, but not essential for basic usage.

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

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

Schema description coverage is 0%, so the description must clarify parameters. It explains 'item' (single bank), 'item_ids' (batch), and the omission pattern for all banks. However, the parameter 'item_id' (a separate string) is not explained, leaving ambiguity about its purpose versus 'item'. Partial compensation but incomplete.

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

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

The description explicitly states it returns the current status of a bank connection, listing specific fields (status, executionStatus, connector metadata, reconnect_url). It distinguishes between retrieving all connections vs. a single one, and mentions bulk support via item_ids. This clearly differentiates from sibling tools like openfinance_list_connections and openfinance_get_account_balance.

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

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

The description provides clear usage guidance: omit 'item' for all connections, pass 'item' for a single connection, and use item_ids for batch execution. It does not explicitly state when not to use, but the context of sibling tools implies appropriate use cases. No explicit exclusions or alternatives are given, which prevents a higher score.

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, covering safety. Description adds batch behavior ({ results, errors }) and array length limit, providing useful 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?

Two sentences front-load key info. Listing many fields may be slightly verbose, but each field adds value for an agent deciding to call this tool. Efficient overall.

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, so description must explain return shape. Lists many fields but lacks structured hierarchy or example. Adequate for a detail tool but not exhaustive.

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

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

Schema coverage is 0%, so description must compensate. It explains loan_ids as an array (1-50) and mentions batch shape, but does not specify format of each ID (e.g., expected from list_loans). Adds some value but not fully explicit.

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

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

Clearly states it returns full loan contract details by ID, listing specific fields. Distinguishes itself from sibling openfinance_list_loans by advising use after listing for deep-dive.

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

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

Explicitly says when to use: after openfinance_list_loans. Provides batch shape and limit (1-50). Lacks explicit when-not or alternatives, but sibling context clarifies purpose.

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

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

Beyond annotations (readOnlyHint, idempotentHint, destructiveHint), the description adds critical behavioral context: meaning of fields, bulk support, provider_incident indicating unreliable data, identity_notice for deduplication. 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 verbose but well-structured with clear sections and front-loaded purpose. Every sentence adds value, though some details could be more concise. Still, it's organized and efficient for its 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 4 parameters, no output schema, and complex behavior (bulk, provider incidents, identity notices), the description covers all necessary aspects: return fields, parameter semantics, edge cases, and integration with sibling tools. It is fully complete.

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

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

With 0% schema description coverage, the description fully explains all parameters: item (single bank vs. all), type (enum), item_id, and item_ids (bulk). It adds value beyond the schema by explaining usage semantics.

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

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

The description clearly states the tool returns accounts for bank connections with specific fields and differentiates between BANK and CREDIT types. It explicitly contrasts with sibling tools like openfinance_list_credit_card_bills, making the purpose unambiguous.

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

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

Provides extensive usage guidance: when to omit or include parameters (item vs. none), warns about credit card balance interpretation, directs to alternative tools for bill details, and explains handling of provider_incident and identity_notice. This enables correct tool selection and invocation.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds caching behavior, single aggregated response, and details on output structure, providing extra transparency 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?

Description is concise (3-4 sentences) with key information front-loaded. Each sentence adds value; minimal redundancy. Slight room for improvement in brevity.

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 parameters and no output schema, description fully explains what the tool returns (id, description, descriptionTranslated, parentId, parentDescription) and behavioral notes (caching, no batch ids). Complete for agent use.

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

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

No parameters exist (schema coverage 100%), so description does not need to add parameter details. Instead, it thoroughly explains the output fields and their uses, which is excellent for no-parameter tools.

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

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

Clearly states it returns Pluggy's transaction category taxonomy, specifies endpoint (GET /categories), describes output fields, and distinguishes from sibling 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?

Implies usage for retrieving categories (e.g., as prerequisite for openfinance_update_transaction_category), but no explicit when/when-not or alternatives compared to other tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context: it explains the reconnect_url's UPDATE mode behavior, that it doesn't consume a connection slot, and that disconnecting is not required first. 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, dense sentence but is well-structured: it first states the main purpose, then elaborates on the reconnect_url. It is efficient with no wasted words, though could be slightly more readable with a break.

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

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

Given no parameters, no output schema, and a simple list operation, the description fully explains what the tool returns and the specific use of reconnect_url. It is complete for an agent to understand the tool's function and 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?

There are zero parameters, so schema coverage is 100% by default. The description adds meaning by detailing what the output contains (connector_id, item_id, bank name, URLs), compensating for the lack of an output schema. Baseline for 0 params is 4, and description meets it well.

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

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

The description clearly states it returns saved bank connections with specific fields (connector_id, item_id, bank name, reconnect_url, add_connection_url). It distinguishes itself from siblings by explaining the reconnect_url's specific use case for re-authentication, not for new connections.

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

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

It explains when to use reconnect_url (re-authentication, MFA, LOGIN_ERROR, stale data) and mentions it does not consume a connection slot. However, it does not explicitly state when NOT to use this tool or compare directly with sibling tools like 'connect' or 'openfinance_disconnect_bank', leaving some inference to 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?

Goes far beyond annotations (readOnlyHint, idempotentHint) by detailing derived payment_status logic, payment cycle nuances, open_bill derivation with confidence levels, connector asymmetry, and bill_grouping_reliability 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?

While lengthy, every sentence adds necessary detail for a complex tool. Front-loaded with core purpose, then logically flows into nuances. Could be slightly more structured, but remains efficient for the complexity.

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

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

Covers all aspects: return fields, payment status logic, open bill derivation, connector asymmetry, warnings, and usage guidelines. Despite no output schema, the description provides a complete mental model for correct tool 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 explains all 5 parameters: account_id (required), include_open_bill (with detailed trade-offs), account_ids (bulk support), page, page_size (implicitly via pagination). Provides critical context beyond schema.

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

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

Clearly states it returns closed credit card bills for a CREDIT-type account, listing specific fields (dueDate, totalAmount, etc.) and derived payment_status. Distinguishes from sibling tools like openfinance_list_transactions by noting its bill-level summaries.

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 (closed bills), when to use include_open_bill for open bills, how payment_status works, and warns against using account balance or summing transactions by billId. Provides alternatives and cross-references to other tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds significant behavioral context: error handling (returns object with warning instead of throwing 403), data integrity cross-checking logic, and explicit instruction to treat suspect_zeroed balances as unavailable. 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 quite long but well-structured: first sentence states purpose, then details return fields, error handling, data integrity logic, and bulk support. It front-loads the main action. However, it could be more concise by grouping related details and omitting redundant phrases (e.g., 'each row carries...' repeats in the data integrity section).

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 6 parameters with no schema descriptions, no output schema, and basic annotations, the description provides rich behavioral context but fails to document parameter usage. The agent understands what the tool does and special edge cases, but cannot reliably construct complete requests without guessing parameter values. The data integrity section adds necessary depth but does not compensate for the parameter gap.

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

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

Schema description coverage is 0%, meaning no parameter descriptions in the schema. The tool description does not explain any of the 6 parameters (item, page, type, item_id, item_ids, page_size). Without this, an AI agent cannot correctly fill in the parameters, severely hindering tool invocation. The description focuses on output and behavior, not input semantics.

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

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

The description clearly states the tool returns an investment portfolio for a connection, listing various asset types (FIIs, stocks, ETFs, etc.). It distinguishes itself from sibling tools like openfinance_list_investment_transactions by focusing on the portfolio overview. The verb 'returns' and specific resource 'investment portfolio' make the purpose unambiguous.

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

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

The description explains when to use the tool (to retrieve investment portfolio data) and provides crucial guidance on handling data_integrity_warning (treat suspect_zeroed rows as unavailable). However, it does not explicitly differentiate use cases from siblings like openfinance_get_account_balance or openfinance_list_transactions, leaving the agent to infer context from the tool name and siblings.

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

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

Annotations already signal read-only, idempotent, non-destructive behavior. The description adds valuable context about the types of movements returned and the bulk support feature. No contradictions are present.

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

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

The description is concise with two short paragraphs. Key information is front-loaded: what it returns, followed by usage order and bulk support. No extraneous text.

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

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

Given the lack of output schema and sparse schema descriptions, the description covers the main behavioral aspects and return fields well. It falls short only by not detailing pagination defaults or limits.

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

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

The schema has 0% description coverage, but the description explains the purpose of investment_id (from openfinance_list_investments) and investment_ids (bulk support). However, pagination parameters (page, page_size) are left unexplained, which is a notable 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 the tool returns movement history for a specific investment position, listing transaction types (BUY, SELL, TAX, etc.) and key fields. It distinguishes from sibling tools like openfinance_list_investments by specifying that this tool is for transactions after obtaining an investment_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?

The description provides explicit usage guidance: 'Use after openfinance_list_investments to get the investment_id.' It also mentions bulk support for batching. However, it does not explicitly state when not to use this tool compared to alternative transaction list tools like openfinance_list_transactions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by disclosing that multiple connections are queried sequentially with rate-limit spacing and the return format '{ results, errors }', which goes 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 concise with three sentences, each adding essential information: purpose and endpoint, parameter details, and behavior when omitted along with return format. 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 the tool's simplicity (one optional parameter, no output schema), the description covers key aspects: purpose, parameter usage, and return structure. It could mention potential limitations like pagination or field details, but it is still complete enough for effective use.

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

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

The input schema has one optional array parameter 'items' with 0% schema description coverage. The description fully compensates by explaining that 'items' contains connection selectors (item_id uuid, connector_id, or connector_name) and that omitting it lists all linked banks, providing crucial meaning absent from 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 lists loan contracts per bank connection, specifying the endpoint 'GET /loans'. It distinguishes itself from sibling tools like 'openfinance_get_loan_detail' by focusing on listing multiple loans rather than a single loan detail.

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

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

The description explicitly explains when to pass 'items' (for specific connections) and when to omit it (to list across all linked banks). It also mentions sequential querying with rate-limit spacing, but does not explicitly name alternatives when not to use this tool.

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

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

Annotations declare readOnlyHint, idempotentHint, and destructiveHint. The description adds critical behavioral details: pagination behavior (auto-pagination up to 5000, manual pagination with page/page_size), error handling (returns {total:0, results:[], warning, error} instead of throwing), detail parameter effects (compact, rich, raw with token costs), bulk support via account_ids, provider incident block, and truncation 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 quite long, but every sentence adds necessary value given the tool's complexity (pagination modes, detail levels, credit card nuances, error handling). It is front-loaded with the primary purpose and structured logically: first general behavior, then credit-specific, then pagination, then detail, then error, then bulk. A minor reduction could improve conciseness, but it remains efficient for the information density.

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 8 parameters, no output schema, and numerous edge cases (credit vs debit, pagination behavior, detail levels, upstream errors, provider incidents, connection health), the description covers all necessary context. It explains the return structure (account echo, truncated flag, warning, error), and provides instructions for verifying account identity and handling zero results for credit accounts. It is fully complete for an agent to use the tool correctly.

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

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

The input schema has 8 parameters with 0% description coverage. The description compensates fully: explains from/to as ISO YYYY-MM-DD, page and page_size for manual pagination, detail enum behaviors (compact default, rich adds merchantInfo and creditCardMetadata, raw returns full transaction), account_id and account_ids for bulk, and search_queries for case- and accent-insensitive substring matching with OR semantics. It adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool returns transactions for bank accounts, distinguishing between BANK and CREDIT types. It explicitly differentiates from sibling tools like openfinance_list_credit_card_bills and openfinance_list_accounts, and specifies the account_id parameter is required.

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 guidance: when to use this tool for itemized credit card transactions, when to rely on openfinance_list_credit_card_bills for standardized totals, how to handle pagination (auto vs manual), when to narrow date ranges if truncated, and how to check connection health via openfinance_get_item_status. It also warns against summing by billId and explains provider incidents.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true. Description adds significant behavioral context: truncation at 5000/account with truncated:true flag, provider_incident block when provider has open incident, and bulk support via item_ids. No contradiction with annotations.

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

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

Description is lengthy but well-structured: starts with core purpose, then parameter details, then special behaviours. Every sentence adds valuable info, though some repetition (e.g., detail options) could be tightened. Still, remains effective for agent understanding.

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 9 parameters, no output schema, and moderate complexity, the description covers: output format (compact summary, raw rows, per-account breakdown), truncation, provider incidents, bulk execution, and example use cases. Provides sufficient context for accurate tool selection and invocation.

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

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

Schema has 0% description coverage, but the description fully compensates by explaining all parameters: item (supports multiple identifier types), from/to (ISO dates), granularity (monthly vs raw), detail (compact/rich/raw), type (BANK/CREDIT), top_n, and item_ids. Also explains defaults and effects.

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 performs consolidated cash-flow analysis for a whole bank connection in one call, resolving accounts internally. It distinguishes from sibling tools like openfinance_list_accounts and openfinance_list_transactions by explaining it avoids separate steps.

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 (e.g., annual/monthly analysis, cash flow, income/expenses) and when not (no need to call list_accounts first). Provides alternative: omit item to analyze all banks. Also advises when to set granularity to 'raw' only if itemized rows 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 declare readOnlyHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context beyond annotations: it reveals upstream outage, known incidents, and flags incidents affecting connected banks via 'your_banks_affected'. No contradiction.

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

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

The description is a well-structured single paragraph that front-loads the main purpose and provides necessary details. While slightly lengthy, every sentence contributes 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 zero parameters, no output schema, the description fully explains what the tool returns (global indicator, degraded components, open incidents, 'your_banks_affected'). It is complete and sufficient for an agent to understand usage.

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

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

The input schema has zero parameters with 100% schema description coverage. Baseline for 0 parameters is 4, and the description doesn't need to add parameter 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 checks the LIVE operational status of the Open Finance provider's public status page, using specific verbs and resources. It distinguishes itself from the sibling tool 'openfinance_get_item_status' by contrasting provider-side health vs. connection-specific status.

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

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

It provides explicit guidance on when to use the tool: when data looks incomplete or stale even though a connection shows UPDATED, and it clarifies that it helps tell apart a provider-side problem from a connection issue. It also mentions what the tool reveals (upstream outage, specific bank/connector incidents).

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 readOnlyHint and idempotentHint are already declared, the description adds plan-dependent filtering, caveat disclosure, and the behavior when keywords are omitted (returns hint instead of dumping catalog).

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 function and then covers nuances. Each sentence adds value, though length could be slightly reduced 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?

Given no output schema, description fully explains return fields, plan behavior, and caveats. Provides everything an agent needs to use the tool correctly.

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

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

Schema coverage is 0%, so description compensates by explaining keywords with examples and required status, and include_accounts triggers returning linked connections. Adds meaning beyond bare schema types.

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

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

The description clearly states it searches bank connectors by name, returning specific fields like connector id, access type, audience, and connect_url. It distinguishes itself from sibling tools by being the search/selection step before connecting.

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 'Call this BEFORE connecting' and explains required keywords, when to surface caveat, and how plan affects results. Provides clear context for when and how 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?

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description reveals a critical behavioral trait: recategorizing automatically creates a Category Rule that affects future transactions. This is valuable context not available from annotations alone.

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

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

Description is well-structured and front-loaded with the core purpose. It uses clear sentences, but could be slightly more concise by removing minor redundancies (e.g., 'teaches Pluggy' phrasing is clear but adds length). Still very effective.

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

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

For a mutation tool with no output schema, description provides complete context: input format, source of IDs, side effects (rule creation), and batch response structure (updated, results, errors). This covers all necessary aspects for an AI agent to invoke correctly.

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

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

Schema coverage is 0%, so description fully compensates. It explains the 'items' array structure, each field's purpose and origin (transaction_id from openfinance_list_transactions, category_id from openfinance_list_categories), and the batch response format.

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 action: 'Corrects the category of one or more transactions' via PATCH /transactions/:id. It specifies the resource (transactions) and action (update category), and distinguishes from sibling tools like openfinance_list_transactions and openfinance_list_categories by explaining where input IDs come from.

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 guidance on when to use: to fix miscategorized transactions and improve future categorization. It tells how to structure the 'items' array and where to source transaction_id and category_id. Does not explicitly state when not to use, but the context is clear enough.

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

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

Annotations already provide idempotentHint=true and destructiveHint=false. The description adds that the conversation array should be included for reproduction, but does not elaborate on other behaviors like side effects or response.

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: first states the purpose, second gives a crucial usage instruction. No wasted words, effectively front-loaded.

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

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

Given no output schema and simple parameters, the description covers the essential use case. It could mention what happens after submission or expected outcomes, but the tool seems straightforward.

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 adds meaning for the 'conversation' parameter (include recent messages), but does not explain 'message' or 'context' beyond their names.

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 reporting bugs, missing features, or sending feedback. This distinguishes it from all sibling tools which focus on open finance operations 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?

The description specifies when to use the tool (to report bugs, missing features, or feedback). It implicitly differentiates from siblings, but lacks explicit 'when not to use' or 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?

Annotations already mark it as readOnly, idempotent, and non-destructive. The description adds that it returns both platform and adapter versions, which is consistent and slightly extends the behavioral insight.

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?

A single sentence that is succinct and front-loaded with the action and object, containing no redundant words.

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

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

For a simple, parameterless read-only tool with annotations covering safety, the description fully specifies its purpose and output scope without needing an output schema.

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 schema coverage is 100%. The description does not need to add parameter-level 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?

The description states it shows current MCP platform and adapter versions, using a specific verb ('show') and clear resource. This distinguishes it from sibling tools that focus on authentication, banking, or marketplace 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 it can be called anytime as a status check, providing clear context. No exclusions or alternatives are needed given its trivial nature.

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, and destructiveHint=false. The description adds valuable detail about what the tool returns—installed MCPs, connection status, accounts, and tool counts—which is exactly the behavioral context an agent needs. No contradiction.

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

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

A single, well-structured sentence that front-loads the verb and result. Every phrase adds meaningful detail ('installed MCPs', 'connection status', 'accounts connected', 'catalog tools') with zero wasted words.

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

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

For a zero-parameter, no-output-schema informational tool, this description is fully complete. It enumerates all categories of information returned, giving an agent enough context to decide when to call it and what to expect.

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

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

The tool has zero parameters, and the baseline for 0 parameters is 4. Since there is nothing to explain about parameters, the description appropriately focuses on output semantics.

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

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

The description uses a specific verb 'Returns' with a clear resource 'current toolkit state' and enumerates the exact contents (installed MCPs, connection status, connected accounts, catalog tool counts). This distinctly differentiates it from sibling action-oriented tools like authenticate or connect.

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

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

The description implies when to use the tool: whenever an agent needs an overview of the toolkit's health and capabilities. It does not explicitly name alternatives, but the sibling tools are clearly specific data-retrieval or auth actions, making this tool's general-purpose role evident.

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