Antecedentes Criminais: SP

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

Beyond annotations (readOnly, idempotent), the description discloses payment requirements, data classification (non-confidential), and LGPD responsibilities, adding meaningful behavioral context.

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 redundant (e.g., repeated references to official sources) and lacks clear structure, but it remains understandable and not excessively lengthy.

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 complex parameter list and no output schema, the description does not explain required fields, return format, or practical usage details beyond basic legal/payment notes. It is insufficient for a user to effectively call the 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 schema has 10 parameters with no descriptions, and the tool description makes no mention of them. Abbreviations like 'rg' and 'cin_cpf' are unexplained, failing to compensate for the lack of 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 clearly states the tool's purpose: querying criminal records (Antecedentes Criminais) from official sources in São Paulo. It distinguishes itself from sibling tools (authenticate, connect, etc.) by its specific domain.

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 implies usage context (consultation from official sources, prepaid credit required) but does not explicitly compare to alternatives or state when not to use it. The context is clear enough given the sibling set.

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 context beyond the annotations: browser login flow, session-only vs permanent connections, and the option to use a config header. It does not contradict the idempotent/non-destructive annotations and clearly discloses the authentication workflow.

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?

Three dense sentences front-load the core flow, then cover configuration and call variants. There is no filler, and each sentence adds necessary information.

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 optional-token tool with no output schema, the description covers the main behaviors, token handling, and persistence model. It does not describe return values, but the link/session semantics are clear enough 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?

The schema has one undocumented optional token parameter with 0% coverage. The description fully compensates by explaining that token is a pasted JWT for session login and that omitting it triggers link retrieval. This completely covers the only 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 authenticates IDE agents by generating a browser login link or accepting a pasted JWT token. It distinguishes the two modes (no-args vs token), though it does not explicitly contrast with the sibling tool 'connect'.

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 usage instructions: call with no args to get the login link, or call with { token: "<jwt>" } after the user pastes it. It also recommends the config-header approach for permanent connections, but it does not state when not to use this tool versus alternatives.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds value by explaining the conditional output based on connection state (authenticated true vs. missing credentials), which is beyond the annotations and helpful for the 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?

Two sentences, front-loaded with the core function, no redundant information. Every phrase earns its place and effectively communicates the tool's behavior and output.

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?

Without an output schema, the description must explain return values; it does so with specifics (authenticated:true, empty pending[], connect_url, per-install URLs). It adequately covers the tool's behavior for a no-parameter status check, though it could mention potential other fields or error scenarios.

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 zero parameters, the schema is fully covered. The description focuses on output behavior rather than parameters, which is appropriate. It meets the baseline for no-parse tools by not repeating schema info.

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 specific outputs based on provider connectivity. It distinguishes itself from siblings like authenticate (which likely initiates auth) by focusing on status retrieval, 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 clear context on when to use the tool (checking connection status and getting URLs for setup) and explains the state-dependent behavior. However, it does not explicitly mention when not to use it or name alternatives, only implying via sibling 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?

Annotations state readOnlyHint=false, openWorldHint=true, but the description goes beyond: it explains that invoke works even when the MCP is not installed, returns connect/checkout links for auth/payment, and clarifies that writes require workspace owner/admin. It also details that search/describe flag installed_in_toolkit vs installed_in_workspace. No contradictions with annotations; openWorldHint aligns with the broad discovery actions.

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 it is structured and front-loaded. However, it is a large block of text that may overwhelm an agent; it could be more organized with bullet points or shorter paragraphs despite the need to explain many actions. Every sentence carries information, so it earns points, but the length hurts 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 params, 14 actions, no output schema), the description is remarkably thorough: it covers the flow, exceptions, permissions, and the prompt library. It goes beyond the schema and annotations, making it complete enough for an agent to select actions and understand consequences. The lack of output schema is mitigated by explaining what each action returns or does (e.g., returns connect link, checkout link, shareable link).

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?

Despite 0% schema coverage in the description, the description explains the core action parameter deeply (all enum values are described, and the flow of action=search → describe → invoke is clarified). It also gives context on parameters like mcp_id, tool_id, arguments (via 'invoke RUNS that tool'), and prompt-related fields (prompt_body, prompt_slug, prompt_vars, prompt_targets). This compensates for lack of per-field documentation, though the large number of parameters (23) means not every one is covered (e.g., limit, immediate, tier_slug, some prompt fields).

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 provides an exceptionally detailed purpose: it identifies the marketplace as the in-platform catalog and execution layer, listing all actions (search, describe, invoke, install, etc.) and the prompt library. It clearly distinguishes the tool from siblings by naming alternatives and positioning itself as the central discovery and execution hub, covering capability requests like 'find an MCP that does X'.

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 explicitly guides when to use each action: use invoke for one-off runs versus install for permanent integration, mentions conditions like credential needs (connect link) and payment (checkout link), and contrasts list_tools vs search. It also states when to prefer alternatives like request_mcp for building new MCPs, providing comprehensive decision-making criteria.

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 indicate idempotent and not destructive, and description does not contradict them. However, description does not detail side effects (e.g., data submission, potential rate limits). With annotations present, the bar is lower, but some behavioral context like 'this sends data to a service' could be added.

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 convey the purpose and a key instruction without unnecessary detail. Well-structured and to the point.

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 reporting tool, the description is adequate. It tells what to do and hints at what to include, but lacks details about expected outcome or confirmation. No output schema exists, so not explaining return is acceptable, but could mention that reporting is asynchronous or logs an issue.

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 description explains the 'conversation' parameter should contain recent messages. It does not explain 'context' or provide details about 'message' beyond its necessity. Description adds some value but not full compensation.

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?

Description clearly states the purpose: reporting bugs, missing features, or sending feedback. It distinguishes from sibling tools like show_version or authenticate.

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?

Description implies when to use (when encountering issues) and explicitly instructs to include conversation array for reproduction, but does not contrast with alternatives like feedback via other tools. It's clear enough for a dedicated reporting tool.

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 behavior is well-defined as a safe read. The description adds no further behavioral context (e.g., output format or dependencies), but it doesn't contradict the annotations. Since the burden is lower with annotations, this 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 sentence that immediately states the purpose. It is front-loaded and contains zero wasted words, making it highly concise and easy to process.

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 0-parameter version-check tool with no output schema, the description is adequate. It specifies what versions are shown (MCP platform and adapter). It could optionally mention the output structure, but that's not essential given the simplicity of the tool, making this nearly 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?

This tool has 0 parameters, so the schema is fully covered. Per the guidelines, the baseline for 0 parameters is 4. The description adds no parameter information, which is fine since there are none.

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 that it shows the current MCP platform and adapter versions. The verb 'show' is specific, and the resource (versions) is identified. This clearly distinguishes it from sibling tools like authenticate or report_bug.

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

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

The tool's purpose is straightforward (checking versions), and while no explicit alternatives are mentioned, the context makes it obvious when to use it. The description implies usage for checking platform/adapter versions, and no other sibling serves this purpose.

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 provide readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds the key behavioral trait that it returns the current state, including connection status and account info, which aligns with read-only and idempotent behavior. It does not contradict annotations and adds meaningful context about what the tool actually reports.

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

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

The description is a single sentence that is concise and front-loaded with the primary purpose. It lists all the key information the tool returns without fluff. Each element (installed MCPs, connection status, accounts, catalog tools) earns its place by defining the output scope.

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 no parameters and no output schema, but the description fully covers what the tool returns. It is complete for a read-only state query tool: it mentions the type of information (MCPs, status, accounts, tool counts) and covers the likely need. It could potentially mention if there are any caveats like requiring authentication, but given the read-only nature and the sibling 'authenticate' tool, it's probably not necessary.

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 0 parameters, so schema coverage is 100%. The description adds meaning by specifying what the tool reports (installed MCPs, connection status, accounts, catalog tool counts) beyond the empty schema. With no parameters, the description successfully clarifies the tool's return content, which is valuable.

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

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

The description clearly states the tool returns the current toolkit state with specific details: installed MCPs, connection status, connected accounts, and number of catalog tools each exposes. It uses a specific verb ('returns') and a specific resource ('toolkit state') and distinguishes from siblings like 'show_version' which likely returns version info, and 'authenticate'/'connect' which handle connections.

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

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

The description implies usage for checking the toolkit state, but does not explicitly mention when to use it versus alternatives. Given the sibling tools (authenticate, connect, marketplace, etc.), it's clear that this tool is for querying state, while others are for actions or other info. It lacks explicit exclusions or 'when not to use' guidance but provides enough context for selection.

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