Captcha Solver

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

The description adds behavioral context beyond the annotations: token can be permanently tied to the server config or only used for a session, and calling with no arguments returns the login link. No contradiction with idempotentHint or other annotations.

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

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

The description is well-structured: it states the flow, the best long-lived option, and the session-only alternative. Every sentence adds relevant information without significant redundancy.

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

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

The description clearly covers the main auth scenarios: no args for a link, token for session login, and config for permanent auth. There is no output schema, and it could more explicitly say return value/error behavior, but the core operation is complete enough for an agent.

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

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

The schema has 0% description coverage for the token parameter, but the description compensates by explaining it is the JWT access token the user pastes, and by describing call shapes like { token: "<jwt>" } or empty args.

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 an authentication mechanism for MCP.AI/: it tells the agent to have the user log in, copy the access token, and either configure it or pass it to the tool. It distinguishes itself from unrelated sibling tools by focusing purely on auth flows.

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 gives explicit guidance on when to pass a token vs. call with no arguments, and contrasts long-lived config auth from session-only auth. It does not explicitly mention sibling alternatives, but the usage modes are clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context: no charge for this operation (billing happens at solve), and bulk support via task_ids. This goes beyond annotations and clarifies cost behavior, which is useful for an agent.

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

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

The description is two sentences, front-loaded with the core purpose, and includes a separate note for bulk support. Every sentence earns its place with no redundancy.

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

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

Given the tool's simplicity (2 params, no output schema), the description covers the essential purpose, billing behavior, and bulk capability. It doesn't explain return format, but with no output schema and a straightforward query operation, this is acceptable. The main gap is parameter relationship details, but overall it's complete enough for an agent to use 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 description coverage is 0%, so the description must compensate. It explains task_id is the identifier for an existing captcha task and mentions task_ids for bulk execution, but doesn't detail format, constraints, or relationship between the two parameters (e.g., whether task_ids is an alternative to task_id). The description adds some meaning but leaves gaps.

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

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

The description clearly states the tool queries the result of an existing captcha task by task_id, which is a specific verb+resource combination. It distinguishes from sibling solve tools by focusing on result retrieval rather than creation, though it doesn't explicitly name alternatives.

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 after a task is created via a solve tool, and notes billing occurs at solve time, not here. It mentions bulk support for batched execution, providing clear context. However, it doesn't explicitly state when not to use it or name alternative tools.

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

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

The description adds meaningful behavioral context beyond annotations: it discloses that each solve consumes credits ('Cobrado em créditos por solve') and that the output is a submission token. The annotations are all false and do not contradict this, but the description does not mention failure modes, async behavior, or error handling.

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 short Portuguese sentences with no filler. It front-loads the main action and then gives the essential output and cost information, making it highly concise and well-structured.

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

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

With two required parameters and no output schema, the description covers the core purpose and return token, which is helpful. However, it is missing parameter semantics and does not address potential failure/retrieval flows, especially given the existence of captcha_get_result among siblings.

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

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

The input schema has 0% description coverage, and the tool description does not explain website_key or website_url. The parameter names are somewhat self-explanatory for hCaptcha, but the description provides no added meaning and fails to compensate for the low schema 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 specific action ('Resolve um desafio hCaptcha') and resource (hCaptcha), and also clarifies the output ('Retorna o token pra submeter no site alvo'). This clearly distinguishes it from sibling CAPTCHA-solving tools by naming the exact challenge type.

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 use when an hCaptcha challenge needs to be solved, but it does not explicitly mention alternatives or exclude other CAPTCHA types. With siblings like captcha_solve_recaptcha_v2 and captcha_solve_turnstile, the tool name carries much of the disambiguation burden.

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 carry no behavioral hints, the description carries the burden. It successfully discloses a key behavioral trait: the operation is charged in credits per solve. It also clarifies that the image is sent as base64 and returns text. It could still mention failure modes or whether the call is synchronous, but adding the cost notice is valuable beyond the schema.

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 deliver the essential meaning: what the tool does, what input to provide, what the output is, and the cost implication. No wasted words, and the key information is front-loaded.

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

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

For a straightforward solve tool, the description gives the main flow and return value, and adds the cost detail. However, with no output schema, no parameter descriptions, and two undocumented optional parameters, it is not fully complete — especially since the sibling captcha_get_result hints at possible asynchronous behaviors that are not addressed.

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, so the description must compensate. It only documents body_base64, while the optional module and case_sensitive parameters remain unexplained. This leaves important semantics about how case sensitivity and the module option work without any guidance.

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

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

The description uses a specific verb ('Resolve um captcha de imagem'), specifies the resource (image/text captcha), and clearly states the output (recognized text). It distinguishes this tool from the sibling recaptcha/hcaptcha/turnstile solvers by limiting scope to generic image captchas.

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 input flow is clear — send a base64 image and get text — so usage is inferable. However, the description does not explicitly say when to prefer this tool over siblings like captcha_solve_hcaptcha or captcha_get_result, nor does it provide any exclusions or alternatives.

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

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

The description discloses that solving consumes prepaid credits, which is meaningful behavioral context beyond the annotations. It also explains the return value as a token. No contradiction with annotations exists. It does not mention failure modes or timeouts, but the core behavior is transparent.

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

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

The description is extremely concise, with three short sentences that each add value: what it does, what it returns, and the cost implication. It is front-loaded and contains no filler.

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

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

For a moderately simple three-parameter tool, the description covers purpose, output, and billing, but it omits guidance on the is_invisible parameter and does not explain parameter semantics. Since there is no output schema, the token description helps, but the missing parameter context keeps it from being 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%, and the description does not explicitly explain the parameters. The names website_url, website_key, and is_invisible are somewhat self-explanatory, and the text refers to the target site, but the description does not compensate for the complete lack of parameter documentation.

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

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

The description clearly states it solves reCAPTCHA v2 challenges and returns the gRecaptchaResponse token for submission to the target website. It differentiates itself from sibling tools by explicitly naming reCAPTCHA v2 and its specific output token.

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: use this tool when you need to solve a reCAPTCHA v2 challenge and obtain a token. It does not explicitly name alternatives or say when not to use it, but the v2 designation separates it from v3, hCaptcha, Turnstile, and image captcha 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 are all false and provide no useful safety signals, so the description does the transparency work. It does disclose credit billing and token return, which is helpful. However, it omits failure modes, timeout behavior, credit prerequisites, and whether the result is immediate or must be collected via captcha_get_result.

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 short, front-loaded, and every sentence adds value: purpose, return value, required parameter hint, and cost model. There is no repetition of schema fields or bloated prose.

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 rich context signals (4 parameters, no output schema, 0% schema description coverage), this description is incomplete. It does not explain min_score, credit prerequisites, size/failure policies, retry behavior, or how the returned token should be consumed. The presence of captcha_get_result in sibling tools also raises unaddressed questions about result flow.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions page_action, leaving website_url, website_key, and, most importantly, min_score semantically unaddressed. Without context, an agent cannot tune min_score correctly even though it is a key reCAPTCHA v3 threshold.

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 is a specific and clear statement: 'Resolve um desafio reCAPTCHA v3' and 'Retorna um token'. It names both the resource type and the CAPTCHA variant, making it easy to distinguish from sibling tools like captcha_solve_recaptcha_v2, captcha_solve_hcaptcha, and captcha_solve_image.

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

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

The description implies this tool is for reCAPTCHA v3 challenges and tells the user to pass the site's page_action, but it does not explicitly say when to prefer this over the v2, hCaptcha, or Turnstile tools. It gives usable context but no exclusions or alternative routing guidance.

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

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

The description discloses that usage is charged in credits per solve and that it returns a token, but it does not mention any potential side effects, delays, or failure modes. Given the annotations provide no additional information, this is moderate transparency.

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 directly conveys the core functionality and cost, with no unnecessary elaboration.

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

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

The description covers the essential purpose and output, but it omits any context about the required parameters (e.g., what website_key is) or additional options. It is adequate for a simple CAPTCHA solver but not fully complete given the presence of two optional parameters in the 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 schema has zero descriptions for parameters, and the description does not explain what website_url, website_key, action, or cdata represent. Since schema coverage is 0%, the description fails to compensate, leaving parameters ambiguous.

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

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

The description clearly states the tool solves Cloudflare Turnstile challenges and returns a token, distinguishing it from other CAPTCHA solvers by the specific type.

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 tool's name and description make it clear it is for Turnstile challenges, but it does not explicitly mention when to prefer it over alternatives like hCaptcha or reCAPTCHA. The context is implied rather than stated.

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

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

The description adds concrete behavioral details beyond the read-only annotation, such as the exact return conditions (authenticated:true vs. connect_url for missing credentials). This is useful additional context not present in 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—two sentences with no redundant wording. It is well-structured, presenting the normal case and the edge case clearly.

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 status check tool, the description covers the essential outcomes sufficiently. It does not detail the URL structure or exact response format, but given no output schema and simplicity, it is adequately complete.

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

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

The tool has no parameters, so schema coverage is trivially 100%. The description does not need to explain parameters, and no additional meaning is added beyond the empty schema.

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

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

The description clearly states it returns connection status and URLs, and explains the two possible outcomes. It distinguishes itself by focusing on status checking, which is distinct from other tools like authentication or CAPTCHA solving.

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 does not specify when to use this tool versus alternatives (e.g., when to check connection status vs. when to authenticate). It provides no guidance on selection criteria or prerequisites.

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

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

The description discloses important side effects and permissions beyond the sparse annotations: 'Writes (install/uninstall/subscribe/cancel and the one-off install behind invoke) require workspace owner/admin.' It also clarifies that invoke runs a one-off without adding the MCP to the toolkit or 'bloating the tool list,' while install makes the MCP show up natively in future sessions. No contradiction exists with destructiveHint=false since uninstall/cancel are reversible configuration changes.

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 densely packed, with a front-loaded definition and a logical flow from catalog → describe → invoke → install → prompt library. Every sentence adds substantive content for a 14-action tool, but the text is sprawling and includes an odd untranslated Portuguese word 'pontualmente' that detracts from clarity. Given the complexity, the size is justified, though a tighter structure would push it higher.

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 23-parameter, 14-action tool with no output schema and minimal annotations, the description covers the core flows, admin permission requirements, one-off vs permanent execution, credential/payment fallbacks, and prompt-library return behavior (shareable mcp.ai/p/<slug> link). It omits explicit return formats for search/list_tools and detailed semantics for several parameters, but the overall behavior is well-specified for an agent to act on.

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, and it does explain the most important `action` enum values and the flow around `mcp_id`, `tool_id`, and `arguments` ('pick the right tool_id', 'invoke RUNS that tool'). However, many of the 23 parameters (e.g., `immediate`, `tier_slug`, `cancel_reason`, `prompt_targets`, `conversation`, `report_context`) remain unexplained and rely on schema names. This is partial compensation, not full 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 opens with a clear, specific definition: 'The official mcp.ai marketplace — the in-platform catalog of every MCP/tool, AND the way to run them.' It then details the core search→describe→invoke flow, naming distinct resources and actions. This strongly distinguishes the tool from siblings like connect and report_bug by framing marketplace as the discovery-and-execution hub plus prompt library.

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

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

Explicit usage guidance is given: 'Use install only to make an MCP PERMANENT in the active toolkit... prefer invoke for a single/occasional use.' The description also spells out when to use each sub-action, including the credential and payment retry flow: 'If the MCP needs a credential/login, invoke returns a connect link; if it is paid and the wallet is empty, invoke returns a checkout/top-up link.' No other tool description here matches this level of when-to-use clarity.

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

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

The annotations indicate idempotentHint: true and destructiveHint: false, which the description does not contradict. The description adds a key behavioral detail: it advises including the conversation array for reproduction, which is beyond the annotations. However, it does not explain other behaviors like whether the report is sent immediately or if there are any side effects.

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—two sentences, no redundant details, and it front-loads the purpose. Every part adds value: the what (report bug/feedback) and the how (include conversation). No waste, appropriately sized.

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

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

The tool is simple with only three parameters and no output schema. Annotations cover idempotency and destructiveness. The description covers the core usage and the key parameter. It could mention that the message is required, but that is evident from the schema. It is sufficiently complete for its complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions the 'conversation' parameter and its purpose (recent messages for reproduction), and the 'message' field is implicitly clarified as the content of the report. However, the 'context' parameter is not explained, but since it is optional and described by name, the coverage is adequate.

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

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

The description clearly states the tool's purpose: reporting bugs, missing features, or feedback. It is distinct from sibling tools which are about captchas, authentication, or version info. The verb 'report' and resource are clear, though it could be more precise about which system receives the report.

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 reporting issues and mentions including the conversation array for reproduction, but it does not explicitly state when to use this tool vs alternatives or any exclusions. It gives a usage hint but no clear scenarios or when-not-to-use.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'Show' behavior aligns with them. The description adds useful detail about what versions are reported without introducing any contradictions or hidden side effects.

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, clearly front-loaded sentence that states exactly what the tool does. Every word contributes meaning and there is no redundant or filler content.

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

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

For a zero-parameter, read-only version information tool, the description paired with the annotations is fully sufficient. There is no output schema, but the description adequately sets expectations for what will be returned.

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 there is no parameter semantics burden on the description. Per the rubric, a zero-parameter tool receives a baseline of 4, and the description does not need to add parameter details.

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

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

The description uses a specific verb 'Show' and identifies the exact resource: current MCP platform and adapter versions. This clearly distinguishes it from sibling tools like captcha solvers or authentication 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 makes it evident this tool is used when version information is needed, but it does not explicitly discuss when not to use it or mention alternatives such as toolkit_info. The usage context is implied rather than fully spelled out.

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 established. The description adds useful output categories but does not go beyond that with details like auth requirements, failure behavior, or formatting conventions.

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 tool's purpose and then lists the key output contents. Every clause adds useful information, with no filler or redundant wording.

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

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

Given the tool has zero parameters, no output schema, and simple read-only annotations, the description is complete for the agent's needs. It names all major return categories and even specifies that tool counts per catalog are included, which is sufficient for 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?

The tool has zero parameters, so the description is not required to explain parameter semantics. The schema confirms no inputs, and the description sufficiently explains what the tool returns without needing to compensate for undocumented parameters.

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

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

The description uses a specific verb ('Returns') and names the exact resource ('current toolkit state'), then enumerates what is included: installed MCPs, connection status, connected accounts, and catalog tool counts. This clearly distinguishes it from sibling tools like connect, authenticate, and show_version.

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

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

The description implies the tool should be used to inspect toolkit state, but it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. Clear enough for a simple read-only info tool, but it lacks direct guidance.

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