Dados Cadastrais PF (Brasil)

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

Annotations already indicate idempotent=true, readOnly=false, and destructive=false. The description adds valuable behavioral details: the permanent non-expiring nature of the header-based auth, the session-only scope of pasted tokens, and the fact that calling with no args returns a login link. It does not contradict any annotations, though it does not describe potential side effects or exact return values for successful token submission.

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 purpose and uses three sentences to cover all invocation modes and configuration options. Every sentence contributes useful information, though there is slight redundancy in 'log in in the browser, copy the access token' and 'paste it here' phrasing, but it remains concise 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?

For a simple one-parameter authentication tool with no output schema, the description is quite complete: it explains the browser flow, permanent vs. session-only options, and how to invoke with or without a token. The main gap is that it does not specify what a successful token-based call returns (e.g., confirmation message), but the core usage is well covered.

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 only defines 'token' as a string with zero description coverage, so the description carries the full burden. It compensates exceptionally well by explaining the token is a JWT copied from the browser, how to use it in the call, and that omitting it returns a login link. This gives far more semantic meaning than 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 explicitly states the tool's purpose: logging into MCP.AI by obtaining an access token from a browser. It clearly describes the resource (MCP.AI) and the action (log in, get link, send token), and the invocation modes (no args, with token, config header) make the behavior unambiguous. It is differentiated from sibling tools by its focus on authentication flow rather than generic connection or utilities.

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

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

The description gives clear usage context: it recommends adding the token as an Authorization header for a permanent connection, or pasting it for a session-only login. It also instructs the agent to call with a token after the user pastes, or with no arguments to get the link. However, it does not explicitly mention when not to use this tool or name alternatives from the sibling list, such as 'connect'.

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 readOnlyHint, idempotentHint, and destructiveHint annotations already establish the safety profile. The description adds value beyond that by disclosing conditional behavior: it returns different fields depending on connection state, including the presence of pending[] and connect_url. This helps the agent interpret responses, though it could be more thorough by covering partial connection states.

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 exceptionally concise — two sentences. The first sentence front-loads the core purpose ('Returns connection status and URLs'), and the second adds necessary conditional detail. Every word earns its place, with no redundancy or 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?

For a tool with no parameters and no output schema, the description adequately conveys the two main outcomes: fully connected and missing credentials. However, it does not describe what happens when only some providers are connected (e.g., whether pending[] is populated). Since the description is otherwise clear and the tool is simple, this is a minor gap rather than a serious deficiency.

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 schema provides complete coverage (100%). The description does not need to elaborate on parameters. According to the rubric, a zero-parameter tool gets a baseline of 4 because there is nothing to contextualize beyond 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's function: 'Returns connection status and URLs.' It specifies the output in different conditions (authenticated:true with empty pending[] vs connect_url when credentials are missing), distinguishing it from siblings like 'authenticate' which likely performs the actual connection. The verb 'returns' and resource 'connection status' are specific and unambiguous.

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

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

The description implies when to use this tool: to check connection status and retrieve URLs. It describes result variations ('When all providers are connected... When credentials are missing...'), giving context on expected outcomes. However, it does not explicitly state when not to use it (e.g., 'use authenticate to connect') or name alternative tools, though the sibling list makes the distinction relatively 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?

The description discloses behavior beyond the annotations: invoke works on uninstalled MCPs one-off, it returns connect/checkout links for auth/billing and then the user retries, install makes MCPs permanent, and writes require workspace owner/admin. These details are not derivable from the annotation flags.

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 and long, but every sentence adds unique value about actions, workflows, or constraints. It is front-loaded with the main purpose, though the wall-of-text format could benefit from bullet points or section breaks for readability.

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, 14 actions) and lack of output schema, the description is remarkably complete. It covers the main workflows, permissions, billing/auth behaviors, installed flags, and the prompt library, with no significant missing context.

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 23 parameters and 0% schema coverage, the description compensates by explaining the core action flow and key parameters (action, mcp_id, tool_id, arguments, prompt_* fields). However, it does not cover several less-common parameters (immediate, tier_slug, prompt_targets, cancel_reason, etc.), leaving gaps for those.

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 'the official mcp.ai marketplace' with a specific role: catalog and execution engine for MCPs, plus a prompt library. It distinguishes itself from siblings by outlining the core flow (search/describe/invoke/install) and listing unique actions like request_mcp and publish_prompt.

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 guidance is provided for when to use invoke vs install ('Use install only to make an MCP PERMANENT in the active toolkit; prefer invoke for a single/occasional use'), and when to use list_tools, subscribe/cancel, report_bug, request_mcp, and prompt actions. Permission requirements for writes are also 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, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds useful behavioral context: 'sem credenciais' (no authentication), 'pague por consulta com crédito pré-pago' (cost side effect), and that data is public/official with LGPD responsibility on the client. 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 three sentences, front-loaded with the core purpose, then covering credentials/billing, and finally legal context. Each sentence adds information, though the third sentence about LGPD is somewhat tangential to tool selection/invocation. Overall it is tight 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?

For a simple read-only tool with 4 flat parameters and no output schema, the description covers purpose, access, cost, and data classification. However, it does not explain the 'completo' parameter or indicate what the returned data looks like, which are relevant gaps for an agent deciding whether this query satisfies the user's need.

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, but it only mentions 'CPF e nome' which loosely maps to Cpf, Name, and Surname. The 'completo' boolean parameter is entirely unexplained, and no format or constraint details are provided. The description adds little beyond the parameter names already present in 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 opens with a clear verb-resource pair: 'Dados cadastrais de uma pessoa física no Brasil a partir do CPF e nome', stating exactly what the tool does. It distinguishes itself from the sibling tools (e.g., authenticate, connect, marketplace) by being the only one focused on Brazilian CPF/name cadastral lookup.

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

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

The description gives clear usage context: this is the tool for querying public cadastral data of a Brazilian individual via CPF and name, with no credentials and prepaid credit charges. It does not explicitly list exclusions or alternatives, but none of the sibling tools serve a similar purpose, 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 the tool is not read-only, idempotent, and not destructive. The description adds the requirement for conversation context, but does not disclose side effects like ticket creation or confirmation behavior.

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

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

Two concise sentences with front-loaded purpose and no filler. Every word serves the tool's 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?

The tool is simple but has 3 parameters and no output schema. The description covers the core action and one parameter but omits explanation for 'context' and does not mention return/confirmation behavior. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly mentions 'conversation array' but leaves 'context' unexplained and 'message' only implied. Additionally, it calls conversation an array while the schema types it as a string, creating minor ambiguity.

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 specific verbs ('report', 'send') and clearly identifies the resources (bug, missing feature, feedback). It distinguishes itself from unrelated sibling tools like authenticate 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 gives clear contextual usage by instructing to include the conversation array for reproduction. It does not explicitly name alternatives or exclusions, but sibling tools are unrelated, so the boundary is obvious.

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, so the safety profile is well covered. The description adds the specific resource (platform and adapter versions) but no further behavioral context such as output format or latency. This is adequate for a simple informational tool, but it does not go 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 a single, clear sentence that is front-loaded and contains no unnecessary words. It fully conveys the tool's purpose without verbose or redundant phrasing.

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 tool with no parameters, no output schema, and comprehensive annotations covering safety, the description is complete. It clearly states what the tool shows, and given the trivial nature of the operation, no additional context is required.

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, so the baseline score is 4. The description correctly focuses on the action and result without needing to explain any parameter semantics, as none exist.

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 function: 'Show the current MCP platform and adapter versions.' It uses a specific verb ('show') and resource ('versions'), and is distinguishable from all sibling tools, none of which relate to version info.

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

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

The description implies use when version information is needed, but it does not explicitly state when to use this tool versus alternatives. However, given the tool's simplicity and distinct purpose, the context is clear enough that no exclusions or alternative references are necessary, though more explicit guidance would help.

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 non-destructive behavior, so the bar is lower. The description adds valuable context by enumerating exactly what state information is returned (installed MCPs, connection status, accounts, catalog tool counts), which goes beyond the generic annotation 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 a single, front-loaded sentence that opens with the action ('Returns') and packs all key information into a readable list. Every word contributes; there is no redundancy or 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 simple read-only tool with no parameters and no output schema, the description fully covers what the agent needs to know: the tool returns a state snapshot with the specified components. It leaves no critical gaps for invocation or expectation-setting.

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 convey. The baseline of 4 applies because the description provides full clarity about the tool's input requirements (none) without needing any 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 uses a specific verb ('Returns') and clearly defines the resource ('current toolkit state') with enumerable details (installed MCPs, connection status, accounts, catalog tool counts). This fully distinguishes it from sibling tools like authenticate, connect, or show_version, which serve different purposes.

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 purpose is so self-evident that usage is clear: use this tool when needing an overview of the toolkit's state. While it doesn't explicitly state when-not-to-use or name alternatives, the context is unambiguous and there is no overlapping sibling tool.

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