Stripe

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

The description explains key behavioral aspects beyond annotations: browser-based login, permanent non-expiring header auth vs session-only pasted token, and that calling with no args returns a login link. It adds useful context without contradicting the idempotentHint or 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?

The description is front-loaded with audience and purpose, then organized with 'Best:' and 'Or' branches. Every sentence earns its place, covering the two auth modes without unnecessary padding.

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

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

The tool's complexity is moderate, and the description covers the core workflow, token format, persistence behavior, and call patterns. It does not specify the success response or error behavior, but it provides enough context for an agent to invoke 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?

With 0% schema description coverage, the description compensates by explaining the token parameter: it is a JWT, optional, and should be supplied after the user pastes it, while omitting it triggers link generation. This adds meaningful semantic value to the bare string 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 authenticates to MCP.AI for IDE agents via browser login and token handling. It names the specific resource and workflow, distinguishing it from generic siblings like connect and report_bug.

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 context and in-tool usage branches: use no args to get a link, and use { token: "<jwt>" } after the user pastes a token. It also recommends the permanent config-header approach over session-only login, though it does not explicitly contrast this tool with sibling alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds concrete behavioral detail: it returns authenticated:true and empty pending[] when all providers are connected, and connect_url plus per‑install URLs when credentials are missing. This goes beyond the annotations and helps predict the tool's output without any 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 single, front‑loaded sentence that immediately states the function and then provides two concrete outcome scenarios. No unnecessary words; every clause 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?

Even without an output schema, the description fully explains the return shape and behavior for both the success case and the missing‑credentials case. For a simple status tool, this is complete and self‑contained.

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 takes zero parameters and the schema is empty (100% coverage). With no parameters to document, the description naturally needs no parameter explanation, earning the baseline of 4 for parameter semantics.

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

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

The description starts with 'Returns connection status and URLs,' which is a specific verb+resource. It distinguishes itself from siblings like 'authenticate' and 'marketplace' by focusing on status checking, making its purpose unmistakable.

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 context for when to use is clear: check connection status. It explains outcomes for connected vs. missing credentials but does not explicitly name alternatives or exclusions. Given sibling names, it's evidently the go‑to for status queries, though it could have been more direct about 'use this when you need connection state.'

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?

Since annotations are sparse (only readOnlyHint=false, openWorldHint=true), the description rightly carries the burden and adds rich behavioral context: invoke's one-off execution without toolkit bloat, the auth/checkout link flow, the owner/admin requirement for writes, and installed_in_toolkit vs installed_in_workspace flags. No contradiction with annotations — readOnlyHint=false is consistent with the described writes (install/subscribe/invoke). Minor gap: no disclosure of list/search return behavior or pagination.

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

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

The description is dense (~500 words) but reasonably structured with 'Core flow:', 'KEY:', and 'Use install only' signposts, and it front-loads the primary purpose early. However, it rambles with extraneous detail (the Portuguese 'consulta um CPF' example, parenthetical asides like 'pontualmente') and much could be tightened. For a 14-action facade some length is justified, but it exceeds what earns top marks.

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 extreme complexity (23 params, 14-action enum, no output schema, minimal annotations), the description covers a lot: core flow, install-vs-invoke semantics, auth/payment link handling, permissions, and the prompt library. But it's still incomplete — no mention of what search/describe/list_tools return, no pagination or limit semantics, and a dozen parameters (immediate, tier_slug, conversation, prompt_vars, etc.) are left unexplained. Above minimum viable but with significant gaps relative to 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 description coverage is 0%, so the description bears full responsibility for 23 parameters, yet it only interprets a fraction: action's 14 enum values, tool_id ('so you pick the right tool_id'), and arguments are implied via 'invoke RUNS that tool'. Entire families — query, limit, immediate, tier_slug, conversation, report_context, cancel_comment, and nearly all prompt_* params (prompt_vars, prompt_targets, prompt_title, prompt_body) — are undocumented in both schema and description. This falls short of compensating for the zero coverage.

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

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

The description states a clear verb+resource: the marketplace is how to 'discover and run' MCP/tools ('find an MCP that does X', 'is there a tool for Y'). It distinguishes itself from siblings by positioning as 'THE way to run them' and the in-platform catalog. The purpose is clear but sprawling — it's a multi-action facade (search/describe/invoke/install/prompts), which slightly dilutes the single-purpose clarity, though the framing is coherent.

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?

Excellent when/when-not guidance: 'Use install only to make an MCP PERMANENT... prefer invoke for a single/occasional use', the explicit core flow (search → describe → invoke), the connect/checkout retry instruction ('the user opens it, then you retry'), and request_mcp for when 'nothing fits'. Write-permission requirements (owner/admin) and the prompt-library-vs-MCP distinction are also spelled out. This rivals the TDQS 4.3 calibration example.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the safety profile is known. The description adds the requirement to include the conversation array for reproduction, which gives useful behavioral context. However, it does not disclose what happens after reporting (e.g., whether a response is returned) or any side effects beyond what annotations imply.

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

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

The description is a single sentence that is front-loaded with the action ('Report a bug, missing feature, or send feedback') and then provides the necessary instruction. Every word is useful, and there is no wasted 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?

The tool is simple (3 parameters, no output schema) and the description covers its core purpose and one key parameter. While it could benefit from explaining the 'context' parameter or clarifying expected outcomes, the current description is adequate for a feedback-reporting tool given the annotations and schema defaults.

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 should explain all parameters. It explicitly explains the 'conversation' parameter as 'recent messages for reproduction', but it does not explain 'context' or 'message' beyond their obvious roles. The description partially compensates for the schema gap but is 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 clearly states it reports a bug, missing feature, or feedback, which is specific and distinct from sibling tools (authenticate, connect, marketplace, etc.). It also specifies the action of including the conversation array, so the purpose is 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 implicitly tells when to use it (when there is a bug, missing feature, or feedback) but does not explicitly state when not to use it or mention alternatives. Given that no sibling tool provides similar functionality, this is acceptable and 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 are all false, so the description carries the full burden. It mentions 'invoke executes a tool by ID', which signals side effects, but doesn't elaborate on consequences, reversibility, permissions, or what might happen to the system. This is a moderate level of transparency—enough to know it can act, but not what the impact is.

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

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

The description is a single sentence that packs three actions and a purpose without wasted words. It's front-loaded and easy to scan. While a bit dense, it earns its place—no fluff. It's appropriately concise for this level of 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 7 params (0 required), 3 actions, no output schema, and all-false annotations, the description should provide more context on expected behavior, outputs, and parameter usage. It only covers the action enum semantics, leaving query, arguments, thresholds, and reindexing unexplained. This is incomplete for a tool that appears central to the MCP catalog.

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

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

Schema description coverage is 0%, meaning the description adds no parameter meaning beyond types and defaults. It only indirectly explains the action parameter through the three actions, but query, queries, tool_id, arguments, min_score, and force_reindex are left unexplained. For a tool with 7 parameters, that's a significant 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 identifies the tool as a single entrypoint to the MCP catalog with three specific actions (search, describe, invoke). This distinguishes it from sibling tools like authenticate or report_bug, which serve different purposes. The verb-resource pairing is explicit 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?

It states the tool is the 'single entrypoint', implying it's the intended way to interact with the catalog, and explains the three actions. However, it doesn't explicitly say when NOT to use it or name alternatives (though siblings are clearly different domains). It provides enough context for an agent to decide when to call it, but without explicit exclusions.

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, covering the safety profile. The description adds the specific target (platform and adapter versions) but no additional behavioral traits like output format or potential latency. With strong annotations, this is adequate but not enhanced.

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, concise sentence that conveys the essential information without any wordiness. It is perfectly sized and immediately 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 the tool's simplicity (no params, no output schema, high schema coverage), the description fully covers what an agent needs to know. It's a complete and self-contained description.

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

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

The tool has zero parameters, so the baseline is 4 as per the rubric. The description correctly implies no inputs are needed, aligning with the empty schema. There is nothing to add beyond this.

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

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

The description clearly states the tool's purpose: 'Show the current MCP platform and adapter versions.' It uses a specific verb ('Show') and identifies the resource (versions). It doesn't explicitly distinguish from sibling tools, but it's a unique operation not overlapping with authenticate, connect, etc., so it's clear enough.

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

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

There is no guidance on when to use this tool versus alternatives. No explicit 'use this when...' or exclusions are provided. The use case is implied from the name and description, but no concrete situational context 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the specific content of the return (installed MCPs, status, accounts, counts), which is useful but doesn't go beyond what annotations provide in terms of behavioral traits like side effects or rate limits.

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

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

The description is a single sentence that is front-loaded with the main purpose ('Returns the current toolkit state') and then lists the specific contents. Every word earns its place; 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 the tool has no parameters, no output schema, and strong annotations, the description is complete enough. It tells the agent exactly what information will be returned, which is sufficient for a read-only informational tool. It could mention whether the data is real-time or cached, but that's a minor 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?

The tool has zero parameters, so the description doesn't need to explain parameter semantics. The baseline for 0 params is 4, and the description correctly focuses on the return value, which is the only meaningful semantic content.

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

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

The description clearly states the tool returns the current toolkit state, listing specific content: installed MCPs, connection status, connected accounts, and catalog tool counts. This specific verb+resource combination distinguishes it from siblings like show_version (version info) and search_tools (searching tools).

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

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

The description implies usage for checking toolkit state, which is clear context. It doesn't explicitly state when not to use it or name alternatives, but the purpose is distinct enough that an agent would know when to call it (e.g., to assess connectivity or tool availability).

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