Prefeitura SP São Paulo: Certidão de Dados Cadastrais do Imóvel

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

Annotations indicate idempotent hint true, but description adds behavioral traits: it can create a permanent connection via config or a session-only login, and it can return a login link when called with no args. This goes beyond the annotations, providing useful context about side effects. 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 a bit verbose and informal, starting with 'MCP.AI for IDE agents (Cursor, etc.):' and containing a long run-on sentence. While it is not excessively long, it could be more succinctly structured with clearer separation of steps.

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 is fairly complete: it explains both invocation modes and the concept of session vs permanent. However, it does not explicitly state what the tool returns (e.g., the link format) or what happens on error, leaving a small gap.

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 coverage, the description fully compensates by explaining the token parameter: 'call with { token: "<jwt>" } after the user pastes, or with no args to get the link.' It clearly describes both the parameter's purpose and the behavior without it, adding meaning 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 purpose: 'MCP.AI for IDE agents (Cursor, etc.): log in in the browser, copy the access token.' This is a specific verb (log in) and resource (access token), making the purpose understandable. However, it does not explicitly differentiate itself from sibling tools like 'connect', though the mention of 'MCP.AI' gives some context.

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 usage alternatives: 'Best: add it to this server's config as a header ... Or paste it here for a session-only login.' It explains when to use permanent vs session login, which is clear context. However, it does not mention when NOT to use this tool versus sibling tools, so it misses the explicit differentiation for a 5.

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 declare readOnlyHint:true and idempotentHint:true, and the description adds significant context beyond that: the exact fields returned (authenticated, pending[], connect_url), and the conditional behavior when credentials are missing. This gives the agent a precise model of what the tool does and returns, going well beyond the structured data.

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 sentences: a clear lead statement followed by two conditional branches. Every sentence adds behavioral information without unnecessary verbosity. The structure front-loads the core purpose and then details specific states, making it easy to scan.

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 good annotations, the description is quite complete, covering the primary success case and the missing-credentials case. However, it doesn't address other potential states (e.g., partial connectivity or network errors), and with no output schema, a bit more exhaustiveness could help, though complexity is low.

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 parameters, the schema coverage is trivially 100%. The description correctly doesn't dwell on parameters, and the baseline for 0 params is 4 per the rubric. No additional parameter info is needed, though a note about the absence of parameters isn't necessary.

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 conditional output behavior. This distinguishes it from siblings like 'authenticate' (the action of connecting) and 'toolkit_info' (general information) by scoping it to connectivity status.

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?

Usage is implied through the described behavior: to check connection status. However, there's no explicit when/when-not guidance or reference to alternatives like 'authenticate', leaving the agent to infer when this is the right tool. A clear usage context but no exclusions or alternatives mentioned.

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

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

The description discloses important behaviors beyond the annotations: writes require workspace owner/admin, invoke runs uninstalled MCPs without bloating the toolkit, missing credentials return a connect link, and empty wallet returns a checkout/top-up link. This adds substantial operational context that the minimal annotations do not convey.

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 but well-organized, starting with the marketplace's role, then the core search/describe/invoke flow, then invoke's key one-off behavior, install vs invoke, and finally the prompt library. Almost every sentence adds unique information, though the wall-of-text format and illustrative examples add some length.

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 extreme complexity—14 actions and 23 parameters with no output schema—the description covers a remarkable amount of necessary context: billing, auth, permissions, one-off execution, installation semantics, and prompt library workflows. Gaps remain around resume, immediate, tier_slug, and more granular parameter behavior, but the description is strong for such a broad dispatcher.

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 and 23 parameters, the description carries a heavy burden. It explains the action enum, tool_id selection, and prompt_vars via the flow narrative, but many parameters such as immediate, tier_slug, resume, report_context, cancel_reason, and prompt_targets are left undocumented. The description compensates for the core flow but not for the full parameter surface.

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 in-platform catalog of MCPs/tools and the mechanism to run them, which goes well beyond the bare name. It outlines distinct internal actions (search, describe, invoke, install, prompt library) and their roles, though it does not explicitly contrast the tool with sibling tools like authenticate or toolkit_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 provides explicit when-to-use guidance: prefer invoke for one-off use, use install only for permanent toolkit additions, use request_mcp when nothing fits, and use list_tools for what is callable now. It also gives clear action sequencing (search → describe → invoke) and notes retry behavior for connect/checkout links.

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=false. The description adds valuable non-obvious details: prepaid payment per query, no platform credentials, official-source nature, non-confidential data, and the client's LGPD controller role. This goes beyond the annotations, though it does not describe the response format or returned certificate structure.

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 compact and front-loaded with the primary purpose, followed by payment, source, and legal context. It is a single dense paragraph, but each sentence adds relevant operational or compliance information, so no sentence is wasted.

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, idempotent lookup with strong annotations, the description covers source, cost, access, and privacy. However, with no output schema, it does not describe what the certificate response contains, and the parameter semantics remain under-specified. It is minimally viable but not fully complete.

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

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

Schema description coverage is 0%, yet the description gives no parameter-specific guidance for login_cpf, login_cnpj, login_senha, cadastro_imovel, or ano_exercicio. It does not clarify required formats, the relationship among credential fields, or what each parameter expects, so it fails to compensate for the low schema coverage.

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

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

The description clearly identifies the resource: 'Certidão de Dados Cadastrais do Imóvel' from the São Paulo prefecture, and the action is 'consulta em fonte oficial'. This specific property-certificate lookup is clearly distinguishable from the generic 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 clear context: the tool is hosted by the platform, requires no platform credentials, uses prepaid per-query credits, queries official Brazilian sources, and involves LGPD responsibilities. It does not explicitly name alternatives or exclusion criteria, but the domain-specific context is sufficient for an agent to identify appropriate usage.

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 idempotentHint=true and destructiveHint=false, but no readOnlyHint. The description doesn't contradict annotations. It adds some behavioral context (reproduction data) but doesn't explain what happens after reporting (e.g., whether it's stored, whether it sends a confirmation). With no readOnlyHint, the tool could mutate server-side state, but the description doesn't explicitly state it creates a record or sends a message.

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

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

The description is short and to the point, front-loaded with the purpose and an instruction to include reproduction data. It avoids unnecessary words, though it could be slightly more structured.

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

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

With no output schema, no enums, and zero schema coverage, the description must explain the full behavior. It's lacking details on how to structure the conversation array, what format the message should take, any limits, and what happens after submission. The tool is a report action, so it might benefit from explaining whether it's a fire-and-forget or returns a reference.

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. However, the description only mentions 'conversation array' but doesn't explain the 'message' or 'context' parameters. The 'message' parameter is required and is the core content, but it's not described. The 'context' default is empty and unclear. This leaves much of the meaning undefined.

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 reports bugs, missing features, or feedback, and mentions including the conversation array for reproduction. This is a specific verb-action combination that distinguishes it from siblings like marketplace or show_version, though it could be more distinct from generic feedback 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?

It says to include the conversation for reproduction, but doesn't explicitly say when to use this vs alternatives (e.g., when not to use it, or if there are other feedback channels). This is implied but not 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context about what is being queried (platform and adapter versions) and matches the annotations, with no contradictions.

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?

A single, front-loaded sentence captures the full purpose without wasted words. It is appropriately sized for the simplicity of the operation.

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

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

For a zero-parameter, read-only version query, the description is sufficiently complete. It does not detail the return format, but the absence of an output schema and the simple nature of the tool make this a minor gap rather than a critical 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, and the schema confirms this. The description has no parameter burden to carry, and the baseline for a zero-parameter tool is strong since agents need no additional parameter guidance.

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

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

The description uses a specific verb ('show') and a clear resource ('current MCP platform and adapter versions'), making the tool's purpose immediately obvious. It also distinguishes this tool from siblings like authenticate, connect, and marketplace, none of which target version information.

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 clearly conveys when to use the tool: when the agent needs version information for the MCP platform or adapter. It does not explicitly mention alternatives or exclusions, but none are needed given the tool's unique role among the sibling 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 read-only, idempotent, and non-destructive behavior. The description adds transparency by specifying what the return content includes, which is useful for setting expectations. It does not mention potential errors or side effects, but for a read-only tool this is acceptable.

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

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

The description is a single concise sentence that front-loads the action ('Returns') and then lists the specific elements of the return value. No fluff or redundant wording is 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 has no parameters and no output schema, the description is sufficiently complete for its low complexity. It explains what the tool does and what data it returns, covering the essential context for a read-only status/info 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 no parameters, so there is nothing to describe. The description appropriately omits parameter details, and since no parameters exist, the semantics are inherently complete.

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, enumerating specific details such as installed MCPs, connection status, accounts, and catalog tool counts. It uses a precise verb and resource, 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 does not provide any guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or typical scenarios. Without such context, users may not know if this is the appropriate tool for status checks or if other tools are better suited.

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