Transparência (CGU)

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

The description discloses that the token can be stored permanently in config or used for a session, and that calling with no args yields a link. This adds behavioral context beyond the annotations (e.g., idempotentHint, readOnlyHint). It also clarifies that the token is a JWT, which is useful. No contradictions with annotations.

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

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

The description is somewhat verbose, starting with 'MCP.AI for IDE agents' which is context but not essential to the tool's function. The flow is a bit rambling: 'log in in the browser, copy the access token' and then 'Or paste it here...' could be tightened. However, it's structured with examples and options, making it acceptable.

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 parameter and no output schema, the description adequately covers the two usage scenarios (permanent vs session) and the no-argument behavior. It doesn't describe success/failure responses, but given its simplicity and lack of output schema, this is sufficient.

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

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

The schema only lists 'token' as a string with no description, leaving 0% coverage. The description compensates by explaining the token is a JWT and that it's optional—calling with no args returns a link, while providing a token performs session login. This adds clear semantic meaning to the parameter.

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

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

The description clearly states the tool is for authentication, describing the login process and token handling. It doesn't explicitly distinguish from siblings like 'connect', but the action is specific enough. The text references logging in and accessing tokens, 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 provides clear usage instructions: either add a token to the server config for permanent access or pass it as a parameter for session-only login, and explains that calling with no arguments returns a link. It gives concrete examples of when to use each approach, though it doesn't mention 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 annotations already declare readOnlyHint=true and idempotentHint=true, so the description doesn't need to repeat safety. It adds valuable state-dependent details: the exact return conditions (authenticated:true with empty pending[] vs connect_url for toolkit and per-install). This goes beyond the schema and annotations, contributing to transparency without 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 two sentences and front-loads the core purpose ('Returns connection status and URLs'). Every clause adds information about the two possible outcomes, with no redundant text.

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

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

Given the simple zero-parameter tool with no output schema, the description covers the essential return scenarios: authenticated with empty pending, and missing credentials with connect_url. It could be slightly more explicit about the structure of pending[] or URLs, but for this tool's complexity, it's 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 accepts zero parameters, so the schema is empty. The description does not need to add parameter meaning, and it correctly focuses on output behavior. Baseline 4 applies for zero-parameter tools.

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

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

The description clearly states the tool 'Returns connection status and URLs' with a specific verb and resource. It explains two distinct states (all connected vs credentials missing), making the purpose unambiguous. However, it does not explicitly contrast with sibling tools like 'authenticate,' so it misses the top score for sibling differentiation.

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 a use case—checking connection status and obtaining connect URLs when credentials are missing—but it provides no explicit guidance on when to prefer this over alternatives like 'authenticate.' No exclusions or alternative tool references are given, so it relies on the agent to infer usage context.

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 key behavioral traits beyond annotations: invoke works even when the MCP is not installed (one-off execution without bloating the toolkit), writes require workspace owner/admin, and invoke returns connect/checkout links when credentials or payment are needed. Annotations only provide readOnlyHint=false and openWorldHint=true, so the description adds substantial context about side effects and permissions. Minor gap: doesn't explicitly state that install/uninstall are destructive or reversible, but the 'permanent' vs 'one-off' distinction covers this.

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

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

The description is a single dense paragraph with no line breaks or bullet points, making it hard to scan. It covers a lot of ground (14 actions, prompt library, permissions, edge cases) but the lack of structure hurts readability. Every sentence adds value, but the wall-of-text format reduces effectiveness for an agent trying to quickly parse usage rules.

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 params, 14 actions, no output schema), the description is remarkably complete. It explains the core flow, the key distinction between invoke and install, permission requirements, and the prompt library sub-system. It doesn't describe return values (no output schema exists), but for a marketplace tool the description covers the essential decision points. Minor gaps: doesn't explain what 'resume' does (only listed in enum), and doesn't detail the difference between installed_in_toolkit vs installed_in_workspace beyond mentioning they're flagged.

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 for 23 parameters. It does explain the key parameters implicitly: action (all 14 enum values are described), mcp_id (used in describe/install), tool_id (used in invoke), arguments (passed to invoke), and prompt_* parameters (for the prompt library). However, it doesn't explicitly map every parameter (e.g., limit, immediate, tier_slug, conversation, report_context) to their usage, leaving some ambiguity for less common actions like subscribe/cancel.

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

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

The description clearly states the tool is the official mcp.ai marketplace catalog and execution platform, covering both discovery ('find an MCP that does X') and execution ('invoke RUNS that tool'). It distinguishes itself from siblings by explaining the core flow (search → describe → invoke) and explicitly contrasting with sibling tools like transparencia_* which are specific MCPs, not the marketplace itself.

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 guidance on when to use each action: 'prefer invoke for a single/occasional use', 'Use install only to make an MCP PERMANENT', and explains when to use search_prompts vs get_prompt vs publish_prompt. It also covers edge cases like credential requirements and payment failures, telling the agent to retry after the user completes the connect/checkout flow.

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

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

Annotations already indicate idempotency (idempotentHint true) and non-destructive behavior, but the description adds that the conversation array is used for reproduction, implying the tool transmits data for debugging. It does not disclose whether data is transmitted externally or stored, but given annotations cover safety, this adds modest value without contradicting any 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 concise sentences, front-loaded with the core purpose and then a useful usage hint. No filler words or redundancy; every part contributes meaning.

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 three parameters and no output schema, the description gives the essential purpose and a key usage detail. It does not clarify the format or expected content of 'message' or 'context', but the overall complexity is low and the description covers the core need. Adequate but with room for more detail.

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

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

Schema coverage is 0%, so the description must compensate. It explicitly mentions the 'conversation' parameter for reproduction, adding meaning beyond the schema. However, it does not explain the 'message' or 'context' parameters, though 'message' is required and likely self-explanatory. Overall, partial compensation is provided.

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 verb 'report' and the objects 'bug, missing feature, or send feedback', which defines exactly what the tool does. It is distinct from siblings since none are related to feedback or bug reporting, making its 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 provides a clear context for when to use the tool (reporting issues or feedback) and offers specific guidance to include the conversation array for reproduction. While it does not explicitly list exclusions or alternatives, the unique purpose among siblings makes it the obvious choice for this use case.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds no extra behavioral details beyond the fact that it shows current versions, which is already implicit in 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, focused sentence with no redundant or extraneous information, making it extremely 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?

Given no output schema, the description sufficiently conveys what the tool does and what it returns (version information). It is complete for its simple purpose.

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, and the schema is fully covered (empty properties). The description adds no additional parameter information, which is acceptable given the high 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 clearly states the tool's purpose: showing current MCP platform and adapter versions. It is distinct from sibling tools like authenticate, connect, or marketplace, which serve different functions.

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 explicitly specify when to use this tool versus alternatives. It implies usage for version checking, but lacks explicit guidance on when not to use it or comparisons to other tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds valuable behavioral detail by specifying exactly what the returned state contains, which is especially important because there is no output schema. It omits details like freshness or rate limits, but for a read-only info tool the disclosure is sufficient.

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, tightly written sentence that front-loads the verb and resource, then clarifies the exact contents with a compact list. Every word earns its place, with no filler 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?

This is a simple, parameterless, read-only tool with no output schema, and the description fully enumerates the fields returned. Annotations cover side-effect disclosure, so an agent has enough information to decide when and why to call this 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?

The tool has zero parameters and the input schema is an empty object, so schema coverage is 100% and there is nothing for the description to add. The baseline of 4 applies because no parameter documentation burden exists.

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' with a clear resource ('current toolkit state') and enumerates four distinct aspects: installed MCPs, connection status, connected accounts, and catalog tool counts. This clearly distinguishes it from action-oriented siblings like authenticate, connect, 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 this is a diagnostic/status tool for inspecting toolkit state, but it does not explicitly state when to use it instead of alternatives or provide any exclusions. Sibling names suggest a use case around pre-connect or post-connect inspection, but that guidance is not made explicit.

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

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

Annotations already mark it read-only, idempotent, and non-destructive. The description adds useful behavioral context: default fase (pagamento), returned fields, and federal-only scope. It does not contradict the annotations, though it omits pagination/ordering 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 dense, well-structured sentences front-load the core purpose and return fields, then end with an alternative-tool pointer. No unnecessary repetition 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 5-parameter tool with no output schema, it covers scope, return fields, default phase, and sibling differentiation. However, parameter semantics are incomplete and it lacks details on pagination/ordering/output structure, leaving meaningful gaps for autonomous invocation.

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

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

With 0% schema description coverage, the description carries the burden but only partially covers parameters. It explains `fase` values and implies `ano`, but omits `pagina`, `ordenacao`, and CPF/CNPJ format. Additionally, 'fase default = 3' conflicts with the schema's string enum, causing 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 clearly states it lists item-level expense documents (Empenho, Liquidação, Pagamento) for a beneficiary, with a specific field list. It also explicitly contrasts itself with the sibling tool `transparencia_despesas_favorecido`, distinguishing its granular, item-level purpose.

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 says when to use this tool (item-level federal expense documents) and provides an explicit alternative for aggregate totals. The 'Só Executivo FEDERAL' scope further clarifies limitations, giving clear context and 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?

The annotations already cover read-only and non-destructive behavior, so the description adds value by revealing aggregation details ('Soma os recursos recebidos e quebra por órgão pagador e por mês') and the default date range behavior. This goes beyond the structured annotations by explaining what the tool actually does with the data. No contradictions with annotations.

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

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

The description is concise and well-structured: it opens with the core purpose, then explains aggregation, followed by an important scope limitation, and ends with the default behavior. Every sentence adds new information without repetition or fluff, making it easy to parse for an AI agent.

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

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

Given the lack of an output schema, the description reasonably explains the expected output structure (summed totals broken down by paying organ and month). It also covers the tool's jurisdiction, default date behavior, and aggregation logic. It omits error-handling or format specifics, but these are not critical for a straightforward read-only query tool with such clear annotations.

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

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

With 0% schema description coverage, the description compensates by explaining that 'CPF/CNPJ' identifies the beneficiary and 'período' is handled via mes_ano_inicio/mes_ano_fim. It also clarifies that without explicit dates, it defaults to the last 12 months, which gives meaning to the optional date parameters. However, it does not specify the expected date format or validate constraints between start and end dates.

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: 'DESPESAS recebidas por uma empresa ou pessoa (CPF/CNPJ) do Governo Federal' and explicitly describes the aggregation behavior ('Soma os recursos recebidos e quebra por órgão pagador e por mês'). It also differentiates from other tools by limiting scope to the federal executive branch, which helps distinguish it from sibling transparency 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 provides explicit guidance on scope: 'IMPORTANTE: cobre só o Executivo FEDERAL, não inclui estados nem municípios (cada ente tem portal próprio)', telling the user when not to use this tool. It also explains the default time period behavior ('Sem datas, usa os últimos 12 meses'), which clarifies usage without explicit dates. However, it does not explicitly reference sibling tools or name alternatives within the same portal.

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 that it returns specific data fields (função/órgão/período), which is useful behavioral context beyond the annotations. However, it does not discuss potential edge cases like CPF not found, which would be a minor gap.

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 concise sentences with no filler. It front-loads the core action ('Verifica se um CPF é...') and then adds the return data and use case. Every word earns its place.

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 single-parameter, read-only tool without an output schema, the description covers the primary purpose, input semantics, return content, and usage context. It lacks explicit error/edge-case handling, but given the tool's simplicity, the coverage is adequate. The sibling context also helps agents understand the tool's niche.

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

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

Schema coverage is 0%, but the description explicitly mentions 'CPF' as the input and states it checks if that CPF is a PEP, thereby adding semantic meaning to the parameter. It does not provide format details (e.g., with/without punctuation), but the core meaning is clear and compensates for the lack of schema 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 the tool verifies whether a CPF is a Politically Exposed Person (PEP) and returns function/body/period. This is a specific verb+resource that distinguishes it from sibling transparency tools (despesas, sancoes) which handle different data.

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 mentions 'Importante para compliance/KYC' which gives a clear context for when to use the tool. It does not explicitly list alternatives or exclusions, but the sibling tools are clearly focused on other domains (expenses, sanctions), so the intended usage is well 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?

While annotations already establish that the tool is read-only, idempotent, and non-destructive, the description adds the return structure (a boolean `tem_sancao` and a list with details like type, agency, grounds, and dates). It does not mention potential errors or limitations, but it is not contradictory.

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, using two sentences to convey the purpose, the consolidated sources, and the return value. No extraneous words are present.

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 (a single parameter and no output schema), the description covers the essential aspects: what it does, the data sources, and the output structure. It could be more explicit about the parameter format, but overall it is fairly 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 schema provides no description for the `cpf_cnpj` parameter, and the description only states it is for a person or company, implying it accepts either CPF or CNPJ. It does not specify the expected format (e.g., digits only, punctuation, length). Given zero schema coverage, this is insufficient.

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: it consults sanctions for a person or company based on CPF/CNPJ and specifies that it consolidates multiple sanction lists (CEIS, CNEP, CEPIM). This distinguishes it from sibling tools that deal with expenses or political exposure.

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 mentions due diligence and compliance, and the consolidated nature of the sanction lists suggests it is appropriate for comprehensive sanction checks. However, it does not explicitly contrast with other tools or clarify 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.