Protestos SP

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

Annotations already include idempotentHint=true and destructiveHint=false. The description adds useful behavioral context: token in config gives a permanent, non-expiring connection, while pasting token gives session-only. It does not fully disclose error handling or security warnings, but it goes beyond the minimal annotation coverage.

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

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

The description is somewhat dense but every sentence carries relevant information. It front-loads the main purpose and then describes two usage modes. A more structured format could improve scannability, but current length is justified by the 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 simple tool with one optional param and no output schema, the description covers the login flow, both permanent and session-based, and the no-args case. It might lack mention of failure responses or post-login behavior, but it is sufficiently complete for an authentication tool.

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

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

Schema has one optional string 'token' with zero description coverage. The description fully explains the parameter's meaning: the JWT pasted by the user for session login, and explains the no-args invocation for obtaining the link. This compensates completely for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: to authenticate with MCP.AI for IDE agents via browser login and token handling. It distinguishes from siblings like 'connect' by specifying the authentication flow (access token, header config) and the two modes (permanent vs session-only).

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 usage guidance: 'Best: add it to this server's config as a header...' for permanent connections, 'Or paste it here for a session-only login' with specifics on token argument. Also clarifies the no-args case to get the link. No ambiguity about when to use which mode.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds meaningful behavioral context beyond annotations by detailing the response in two key states: when all providers are connected (returns authenticated:true and empty pending[]) and when credentials are missing (returns connect_url and per-install URLs). This clarifies the dynamic behavior without contradicting the safety hints.

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, concise and front-loaded with the main purpose. Every clause adds value by explaining the two primary outcomes, making it efficient with 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?

With no output schema, the description serves as the primary source for return values. It covers the main scenarios (all connected, credentials missing) and mentions key fields (authenticated, pending[], connect_url, per-install URLs). It may not exhaustively list all possible states, but for a simple status tool, it is sufficiently complete.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. Per the rubric, a baseline of 4 is appropriate. The description does not need to compensate for any schema gaps since the schema is empty and fully 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 states the tool's purpose: 'Returns connection status and URLs.' It specifies the resource (connection status) and the verb (returns), and distinguishes it from siblings like authenticate by focusing on status rather than the action of connecting. The description also provides concrete details about return values under different conditions, 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?

The description implies usage by explaining what happens when providers are connected vs. credentials missing, but it does not explicitly state when to use this tool versus alternatives like authenticate or provide any exclusion criteria. There is no mention of 'use this if' or 'instead of', so guidance is only implied.

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

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

Beyond the annotations, the description discloses that writes (install/uninstall/subscribe/cancel and the one-off install behind invoke) require workspace owner/admin, that invoke runs tools without installing them, and that credentials or empty wallets produce specific link responses. This adds significant behavioral context not evident from the schema or annotations.

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

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

The description is long and dense, but every sentence contributes critical operating detail for a tool with 23 parameters and 14 actions. It front-loads the core flow and highlights the key invoke behavior early. The structure is a single paragraph, which hurts scannability, but the content is information-dense and avoids 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?

Given the tool's complexity—23 parameters, no output schema, multiple actions—the description covers all major operations: search, describe, invoke, install, uninstall, subscribe/cancel, list_tools, report_bug, request_mcp, and the prompt library. It specifies return behaviors for invoke (connect link, checkout link) and publish_prompt (shareable link), and notes auth requirements. The description is effectively complete for an agent to select and 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 meaning of key parameters like action, mcp_id, tool_id, arguments, and prompt fields. It does not explicitly detail every parameter (e.g., limit, query, conversation), but the action enum is well mapped to use cases, and most other parameter names are self-explanatory. The core semantics are covered, though a few edge-case params remain 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 defines the marketplace as the official catalog of MCPs and the way to run them, with a specific core flow (search → describe → invoke). It distinguishes itself from siblings by focusing on discovery, profiling, and execution of MCPs, plus a prompt library, making its role 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 description provides explicit when-to-use guidance: prefer invoke for one-off runs, use install for permanent toolkit additions, use list_tools to see what's callable, and use subscribe/cancel for billing. It also details alternative actions like request_mcp and report_bug, and even explains fallback behavior when credentials or payment are needed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond these: it is hosted by the platform, requires no credentials, is paid per query with prepaid credit, and imposes legal obligations under LGPD (client is controller). This clarifies the operational and compliance aspects without contradicting 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 a compact paragraph with the first sentence front-loading the core purpose. Each subsequent sentence adds relevant information (hosting, payment, legal basis). It is not overly verbose and all content earns its place, though a bulleted structure could improve scannability.

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 read-only tool with 3 parameters and no output schema, the description covers the main aspects: data source, payment model, and legal requirements. However, it omits details about the 'completo' parameter, the fact that both Cpf and Cnpj are required, and any details about response format or limitations. These gaps make it incomplete for an agent that needs 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?

The description does not explain the parameters (Cpf, Cnpj, completo) and schema description coverage is 0%. It indirectly references CPF/CNPJ via 'pessoas físicas e jurídicas', but the purpose of 'completo' is left ambiguous. The schema requires both Cpf and Cnpj, yet the description does not clarify this unusual requirement, leaving the agent without enough information to correctly populate the 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 clearly states the tool's purpose: to consult the existence and data of protests (protestos) for individuals and legal entities in São Paulo notary offices. It uses a specific verb (consultar) and identifies the resource (protest data), which distinguishes it from the unrelated sibling tools like authenticate, connect, and marketplace.

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

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

The description provides context for when to use the tool: for credit information from bureaus and official databases, with a required legal basis (e.g., risk analysis requested by the data subject or contractual relationship). It does not explicitly compare to alternatives, but the siblings are not related to credit consultations, so the guidance is sufficient.

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 useful context beyond the annotations by specifying the need to include the conversation array for reproduction. However, it does not explain the operation's side effects beyond 'report,' nor does it clarify the implication of idempotentHint: true. Annotations already indicate a non-read-only, non-destructive operation, and the description aligns with that but omits further behavioral 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, consisting of two sentences that are immediately relevant. It front-loads the core purpose and then provides one critical usage tip. Every sentence earns its place without 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 tool is simple with three parameters and no output schema, so the description need not be extensive. It covers the overall purpose and highlights the conversation parameter, but it lacks clarification for the required message parameter and any indication of what the user should expect as a result. This is adequate for basic understanding but leaves 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?

Schema description coverage is 0%, so the description must compensate by explaining parameters. It only mentions the 'conversation' parameter explicitly, leaving the required 'message' parameter and the optional 'context' parameter unexplained. This is a significant gap since 'message' is required for the call to succeed.

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 with specific actions: 'Report a bug, missing feature, or send feedback.' This distinguishes it from all sibling tools, which are unrelated to reporting. It uses a clear verb and resource, making the tool's function immediately obvious.

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

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

The description gives explicit guidance on when to use the tool ('Report a bug, missing feature, or send feedback') and provides a crucial instruction: 'Include the conversation array with recent messages for reproduction.' It does not mention alternatives or exclusions, but the sibling tools do not overlap with this functionality, so the context is sufficient.

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 the specific behavioral context that the tool returns platform and adapter versions. This is a simple read-only operation, so no further side-effect disclosure is necessary.

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?

One short, direct sentence that front-loads the action and result with no wasted words. It earns every word it uses.

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

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

For a no-argument, read-only version tool, this description is fully complete. It states what the tool does and what information is returned, which is sufficient for an agent to select and invoke it among the given 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?

There are no parameters, and schema description coverage is 100% by vacuity. The description correctly omits parameter details, as there is nothing to explain.

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 a clear resource ('current MCP platform and adapter versions'), distinguishing it from sibling tools like authenticate or connect. It fully communicates what the tool does.

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?

No explicit when-to-use or alternative guidance is given, but the purpose is self-evident: it should be used when version information is needed. There are no exclusions or alternatives mentioned, so usage 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description need not restate safety. It adds concrete behavioral detail by specifying exactly what data is returned (installed MCPs, statuses, accounts, tool counts), which goes beyond the annotation coverage and helps the agent set expectations.

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, information-dense sentence that starts with the action verb 'Returns' and immediately specifies the outputs. No redundant words 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's simplicity (no params, no output schema), the description adequately covers what an agent needs to know for selection: what the tool returns. It lists the major categories of information, though it could potentially detail the structure of the returned data, which is not necessary 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?

This tool has zero parameters, so the schema is trivially 100% covered. The baseline for 0 parameters is 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 the specific verb 'Returns' and clearly specifies the resource 'current toolkit state', enumerating its components: installed MCPs, connection status, accounts, and catalog tool counts. This distinguishes the tool from sibling tools that perform actions like 'authenticate', 'connect', or '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 is for querying overall toolkit state without explicit when-to-use or alternative exclusions. While it doesn't explicitly compare against siblings like 'show_version', the clear listing of returned data gives the agent enough context to know when to select it, but lacks explicit guidance on 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.