SINTEGRA: AM

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

It discloses key behaviors: browser login, permanent non-expiring token via config, session-only token paste, and no-args behavior returning the link. This complements the annotations without contradicting them; the idempotentHint and destructiveHint are consistent with the described 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?

The description is compact and information-dense, covering context, two authentication modes, and call patterns in two sentences. It is slightly dense in the opening clause, but every sentence adds necessary value.

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 authentication tool with one optional parameter and no output schema, the description covers the main workflow, configuration option, session login, and no-args link retrieval. It lacks failure/error handling details but is otherwise complete for practical use.

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?

Although the schema has no parameter descriptions and coverage is 0%, the description explains the only parameter 'token' as a JWT to paste for session-only login, and defines behavior when omitted. This compensates well for the missing schema-level semantic information.

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 explains that the tool handles authentication for MCP.AI with a browser login and access token flow. It is not explicitly differentiated from the 'connect' sibling, but the purpose is specific and actionable.

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 guidance on when to use the permanent config-header approach versus a session-only token login, and when to call with or without arguments. It does not explicitly compare against sibling tools like 'connect', but the usage paths are well defined.

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, so the safety profile is covered. The description adds valuable behavioral details about the response (authenticated:true vs. connect_url and per-install URLs), which goes beyond the structured 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 two sentences, front-loaded with the primary purpose, and each sentence provides distinct conditional information. No wasted words.

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, parameterless read-only status tool with no output schema, the description is complete. It explains both the success case (all providers connected) and the failure case (missing credentials), covering the key behavioral outcomes.

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 schema coverage is 100%, so the baseline is 4. The description correctly focuses on behavior rather than parameter syntax, which is appropriate when no parameters 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 uses a specific verb ('Returns') with a clear resource ('connection status and URLs'), and the conditional logic distinguishes it from sibling tools like 'authenticate'. It clearly explains what the tool does and its two possible outcomes.

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 connection status, but it does not explicitly say when to use this tool versus alternatives such as 'authenticate'. The context is clear but there are no explicit exclusions or alternative recommendations.

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 only declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false. The description goes well beyond by explaining key behaviors: invoke runs tools pontualmente without installation, returns connect/checkout links on auth/payment failures, and requires owner/admin for writes (install/uninstall/subscribe/cancel). It also explains prompt library behavior (get_prompt fills {{variables}}, publish returns shareable link). No contradiction with annotations; in fact it clarifies the non-read-only nature. However, it doesn't detail error handling for all actions or what happens on retry.

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 block, front-loaded with the core flow (search→describe→invoke) but then diverges into many details without clear structure. Every sentence adds value, but the long list of actions and prompt library could be organized with bullet points or sections. It is longer than necessary, but not bloated—still, structure could be improved.

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 high complexity (23 params, 14 actions, no output schema), the description is quite thorough. It explains the main flow, the key nuance of invoke (runs without install, returns links), the difference between one-off and permanent install, and the prompt library. It omits specifics on some actions (resume, report_bug detail) but overall provides a functional mental model for the agent. The absence of output schema makes this description crucial, and it does a good job.

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 description must compensate. The description explains the flow but doesn't map specific parameters to actions beyond mentioning action values and key params like mcp_id, tool_id, arguments, prompt_vars. Most parameters (e.g., cancel_reason, prompt_targets, limit) are undocumented in the description, leaving the agent to infer from the schema. This is a gap, but the description's core flow (search/describe/invoke) covers the most critical parameters, earning a baseline 3.

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 this tool is the central marketplace and dispatcher for MCPs and prompts, covering multiple actions. It distinguishes itself from siblings by listing its sub-actions (search, describe, invoke, etc.) and explicitly mentions the prompt library, which siblings like authenticate or connect don't cover. However, the purpose is broad and could be confused with a general assistant, but it is specific enough as a hub for MCP discovery and execution.

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 when-to-use guidance for core actions: use search to find MCPs, describe to get details, invoke for one-off runs, install for permanent ones. It explicitly contrasts invoke vs install ('prefer invoke for a single/occasional use') and mentions that invoke works even without installation. However, it doesn't cover all 14 actions (e.g., resume, report_bug, request_mcp are only implied) and doesn't explicitly say when NOT to use this tool (e.g., when a specific sibling like authenticate would be better).

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 idempotentHint=true and destructiveHint=false, covering the safety profile. The description adds the actionable detail of including the conversation array for reproduction. However, it does not disclose post-invocation behavior such as whether the report is sent externally or what the response contains.

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 extremely concise, comprising two short sentences that front-load the core purpose and then add a single crucial usage hint. Every word earns its place, and there is 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?

This is a simple tool, and the description covers its primary purpose and provides one key parameter hint. However, the absence of an output schema and lack of clarity about the conversation parameter leave some gaps. The annotations cover mutation behavior, but the description could be more complete about expected outcomes or error handling.

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 does add meaning to the 'conversation' parameter by mentioning it as an array, but this contradicts the schema type (string) and could mislead an agent. The 'message' and 'context' parameters are left unexplained, providing insufficient 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 clearly states what the tool does with a specific verb and resource: 'Report a bug, missing feature, or send feedback.' It also includes a specific instruction about including the conversation array, which further clarifies its purpose. This distinguishes it 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?

The description makes it clear the tool is for reporting issues or feedback, which is sufficient context for when to use it. It does not explicitly mention alternatives or exclusions, but no other sibling tool overlaps in functionality. Thus, it provides clear usage context without formal guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate them. It adds the subject (platform/adapter versions) but gives no detail on return shape or runtime behavior. This is adequate given the simple read-only nature, but not rich.

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

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

One short, information-dense sentence. It states the action and the exact target without any 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?

Given the tool's simplicity—zero parameters, read-only, no output schema—the description is fully sufficient. It clearly communicates what the tool returns and is consistent with annotations, making it a complete entry for this utility.

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 is an empty object, so there is nothing to document. With schema description coverage at 100%, the baseline of 4 applies; the description correctly omits parameter details.

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

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

The description uses a clear verb ('Show') and specific resource ('current MCP platform and adapter versions'). It is easily distinguished from sibling tools like authenticate, connect, or report_bug, which cover entirely different actions.

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 no guidance on when to use this tool vs alternatives. It does not mention typical scenarios, prerequisites, or whether it should be used for environment checks. This is purely a functional description with no contextual advice.

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 meaningful context beyond that: queries are paid per consultation via prepaid credit, no platform credentials are required, data is public and non-confidential, and the client is the LGPD controller. This is useful behavioral and operational 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 text is front-loaded with the core purpose and is only three sentences, but the legal and commercial details (LGPD, controller responsibility, payment conditions) could be condensed. It is acceptable but not maximally concise.

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 two-parameter read-only tool, the description covers payment, official source, and data privacy obligations reasonably well. However, with no output schema present, it does not explain the return value shape, potential error cases, or how the optional IE parameter behaves, leaving noticeable 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%, and the description does not mention the 'cnpj' or 'ie' parameters at all, nor their formats, constraints, or relationship to SINTEGRA queries. The required parameter is left completely implicit, so the description adds no value beyond the raw 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 identifies a specific query operation ('consulta') against SINTEGRA AM, an official Brazilian source, and clearly differentiates it from sibling platform management tools like authenticate, marketplace, and report_bug. However, it does not explicitly state what data is returned, relying on prior knowledge of SINTEGRA.

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 commercial and legal context (prepaid credits, no credentials, LGPD) but gives no explicit guidance on when to use this tool versus alternatives or when not to use it. Sibling tools are unrelated, so there is no differentiation or exclusion guidance.

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 description need not repeat these. It adds value by specifying exactly what data is returned—installed MCPs, connection status, accounts, and tool counts—which is useful contextual information beyond the annotations. No contradictions observed.

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, well-structured sentence. It front-loads the action ('Returns the current toolkit state') and then lists the specific components returned. No redundant or filler content; every word adds value.

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 read-only with no parameters and no output schema. The description lists all key aspects of the returned state, which is adequate for an agent to understand the tool's output. It doesn't mention error handling or latency, but these are not essential for a simple info tool. Overall, it is sufficiently complete for its complexity.

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 per the rule, baseline is 4. The description doesn't need to explain parameters since there are none to document. The schema is empty, and the description adds no parameter information, which is appropriate.

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's purpose with a specific verb+resource: 'Returns the current toolkit state' and details what that entails (installed MCPs, connection status, accounts, catalog tool counts). It is distinct from siblings which perform actions like connect 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?

The description implies usage for inspecting toolkit state, but it does not explicitly state when to use this versus alternatives like show_version or marketplace. However, its purpose is clear enough that an agent can infer when to call it. No exclusions are mentioned, but none are needed for an info tool.

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