Superlógica Condomínios

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

Annotations provide idempotentHint and destructiveHint but not deeper behavioral context; the description adds meaningful transparency by explaining that config-based auth gives a permanent non-expiring connection while passing a token creates a session-only login. It does not overclaim or contradict 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 reasonably concise and each sentence contributes actionable information: workflow, permanent config option, and session-only call modes. The phrasing is a bit run-on and mixes user instructions with API behavior, but it remains efficient.

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-optional-parameter auth tool with no output schema, the description covers the main call patterns and setup options. It could be stronger by explicitly noting that this authentication is prerequisite for the sibling tools, but the provided flow is sufficient for an agent to invoke it correctly.

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

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

The schema only defines an optional 'token' string with no description, and the description compensates by explaining that the token is a JWT and that omitting arguments yields a login link. This is useful semantic detail beyond the bare schema.

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

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

The description clearly identifies the tool as a login/authentication flow for IDE agents, and distinct call modes are stated (no args for a link, token for session login). However, the first sentence is somewhat unstructured and mixes browser/user instructions with tool behavior, so it is not a crisp 'this tool does X' statement.

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 guidance on when to pass a token versus call with no arguments, and explains the permanent config approach versus a session-only login. It lacks an explicit when-not-to-use warning or comparison with alternative auth methods, but the context is clear enough.

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 clear. The description adds valuable behavioral context beyond annotations by describing conditional outputs: authenticated:true and empty pending[] when all providers are connected, and connect_url plus per-install URLs when credentials are missing. This gives the agent a model of what to expect, though partial-connection states are not explicitly described.

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 purpose and then the conditional details. Every sentence earns its place, with no repetition of annotation information or unnecessary 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?

With zero parameters, no output schema, and annotations covering the safety profile, the description does a solid job explaining return values in the two most common states. The mention of 'empty pending[]' when connected and 'connect_url' when credentials are missing gives enough of a model for an agent to interpret results, though partial connectivity semantics are left implicit.

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 an empty input schema, so schema description coverage is trivially 100%. There is no parameter documentation burden for the description to carry, so the baseline of 4 applies.

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 states a specific verb and resource: 'Returns connection status and URLs.' It also gives two concrete response states, which clearly distinguishes it from sibling tools like 'authenticate' that perform an auth flow rather than report status. An agent can tell this is the status-check tool without opening any schema.

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 the tool to call when you need to check whether providers are connected, but it never explicitly says 'use this instead of authenticate' or provides when-not guidance. The conditional return behavior allows an agent to infer common use cases, but no alternatives are named.

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?

Beyond the annotations, the description discloses important behavioral details: writes require workspace owner/admin, invoke runs one-off without installing or bloating the toolkit, install makes an MCP permanent, and paid/credential-required cases return actionable links. These are meaningful behavioral traits that the annotations alone do not convey, and nothing in the description contradicts 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 dense and front-loaded, leading with the core marketplace purpose and the KEY invoke behavior, with no filler. It is, however, a long single paragraph that mixes billing, permissions, the core flow, and the prompt library; bullets or short sections would make the action-specific guidance easier 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 complex 23-parameter dispatcher with no output schema, the description covers the core lifecycle, permissions, auth and payment edge cases, and the separate prompt-library subsystem. It still leaves gaps around the 'resume' action, the 'immediate' parameter, and the exact result shapes of search and list_tools, so it is 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?

With 0% schema description coverage, the description compensates by mapping the main action values to their purposes and to related parameters like query, mcp_id, tool_id, and arguments. It also covers the prompt-library parameters. However, several of the 23 parameters, such as immediate, conversation, cancel_reason, cancel_comment, and prompt_targets, are left unexplained, so the compensation is substantial but incomplete.

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 first sentence identifies the tool as the official mcp.ai marketplace, and the rest enumerates its capabilities across discovery, description, invocation, installation, billing, and prompt-library operations. It is a specific, multi-action dispatcher rather than a vague restatement, and its scope is clearly separate from the superlogica siblings.

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 routing guidance: use install only to make an MCP permanent, prefer invoke for single or occasional use, use list_tools for what is currently callable, and use request_mcp when nothing fits. It also explains the search → describe → invoke flow and when invoke will return connect or checkout links, so an agent knows how to proceed in each state.

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 cover readOnlyHint, destructiveHint, openWorldHint, and idempotentHint, so the description's burden is lower. It adds the key behavioral nuance that conversation history should be attached for reproduction. It does not disclose what happens after submission, but this is not safety-critical given the non-destructive, idempotent 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?

One sentence, no filler, and the purpose comes before the usage instruction. The description is tightly written and earns every word.

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: three parameters, no output schema, no nested objects. The description covers the core purpose and the reproduction requirement, but it omits what the message should contain, what context means, and what the agent should expect after reporting. It is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies the conversation parameter ('recent messages for reproduction'). The required 'message' parameter and the 'context' parameter are left undocumented, and calling conversation an 'array' is slightly misleading since the schema declares it as a string with a '[]' default.

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 states a specific verb and resource: 'Report a bug, missing feature, or send feedback.' This clearly distinguishes the tool from the many operation-focused superlogica siblings and makes its purpose immediately obvious.

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

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

The description gives clear invocation use cases: bugs, missing features, and feedback. It also tells the agent to include the conversation array for reproduction. No sibling tool offers this function, so explicit exclusions are unnecessary, but they are not stated either.

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 clear. The description adds only the word 'current,' implying a live query of version state, but does not disclose output shape or whether any network/adapter interaction occurs. This is acceptable for such a simple read-only tool but adds little beyond the annotations.

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

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

A single sentence with no filler, front-loading the verb and object. Every word earns its place, and the description is appropriately sized for a trivial no-argument tool.

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 no-parameter, read-only version display tool, the description covers the essential invocation context and names both platform and adapter versions. It is slightly incomplete in not mentioning what the response will look like, but that is a minor gap given the simplicity of the operation.

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

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

The tool has zero parameters, so the schema leaves nothing to document. Per the baseline for parameterless tools, the description need not compensate for missing parameter documentation.

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

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

The description states a clear verb and resource: 'Show the current MCP platform and adapter versions.' It is immediately obvious what the tool does and it is distinguishable from the domain-specific superlogica_* siblings, though it does not explicitly differentiate itself from toolkit_info or other generic metadata 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 no guidance on when to use this tool versus alternatives, and there are no explicit exclusions or references to sibling tools like toolkit_info. Usage context is only implied: use it when version information is needed.

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 includes the tag '[write, altera dados]', which confirms the operation is a write/mutation, but this largely repeats what the readOnlyHint=false annotation already conveys. It does not disclose important behavioral details such as what 'desfazer' actually does to the agreement, whether the action is reversible, what authentication is needed, or what side effects may occur.

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 front-loaded, with no filler words, but it is under-specified for a tool with three undocumented parameters. While it is concise in wording, it is not appropriately sized because it omits essential invocation details.

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 three undocumented parameters, no output schema, and no usage guidance, the description is incomplete for an agent to call the tool correctly. It gives the domain ('Receitas / Acordos') and the HTTP method, but leaves the request body, query parameters, and account handling entirely unspecified.

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

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

The input schema defines three parameters (body, query, account) with no descriptions, and the schema description coverage is 0%. The description provides no information about what these parameters mean, how to format them, or which are needed for this endpoint, leaving the agent without any usable 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 states a specific verb ('Desfazer') and resource ('acordo'), and includes the exact HTTP endpoint (PUT /acordos/desfazer), making the tool's purpose immediately clear. It also distinguishes this tool from sibling tools like superlogica_acordos_list and superlogica_acordos_put by naming the undo action.

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 no guidance on when to use this tool versus alternatives such as superlogica_acordos_put or superlogica_acordos_list. It provides no prerequisites, no exclusions, and no conditions that would help an agent decide between this and related agreement 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 communicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe read-only nature is clear. The description adds the GET endpoint but does not disclose return shape, pagination, or account-related requirements.

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 front-loaded with the resource and action. The leading breadcrumb 'Receitas / Acordos / Obtendo dados para gerar o acordo' is somewhat redundant but not excessively wordy.

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?

There is no output schema, no parameter documentation, and no mention of pagination or return data shape. For a list tool with two optional string parameters, this description is insufficient for fully correct invocation and response interpretation.

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 explain what 'query' or 'account' represent. With two undocumented parameters, an agent has no basis for knowing what values to provide or whether they are filters, identifiers, or pagination controls.

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

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

The description explicitly states 'Listar acordos existentes (GET /Acordos)', which gives a clear verb, resource, and HTTP method. It is distinguishable from sibling write/simulation tools, though it does not explicitly name them.

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?

There is no guidance on when to use this tool over siblings like superlogica_acordos_simularparcelas or superlogica_acordos_put. There is also no mention of filtering, pagination, or how 'query'/'account' should be used in practice.

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 labels the operation as '[write, altera dados]' and says it creates a new agreement, which matches readOnlyHint=false. It adds little beyond the annotations, but the mutation intent is at least explicit and consistent.

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 compact sentence with a domain prefix and operation tag, so it is efficient and front-loaded. The endpoint path and write tag add some functional context, though the wording is terse.

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 description provides only high-level intent. With three undocumented parameters and no output schema, the agent cannot reliably construct a correct request or understand the expected return value.

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 explain body, query, or account. There is no indication of the payload format, required fields, or how the arguments should be structured.

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 as 'Receitas / Acordos' and the action as 'Novo acordo', so the agent knows the tool creates a new agreement. It does not explicitly contrast the acordos siblings, and the endpoint notation 'POST /acordos/put' is slightly confusing.

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 only implied: 'Novo acordo' suggests this is the creation tool among the acordos siblings. No explicit conditions, prerequisites, or when-not-to-use guidance is provided.

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. The description's 'GET' and 'simulando' are consistent with these hints and add the context that this retrieves data, not modifies it. It does not add further behavioral details like output shape or prerequisites, but it does not contradict 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 short and not bloated, but it opens with a category breadcrumb ('Receitas / Acordos /') rather than the actionable purpose, and the endpoint largely repeats the tool name. It is compact but not optimally front-loaded.

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 and undocumented parameters, the description needed to explain what query and account mean and what simulated parcel data is returned. It only says 'obtaining data,' which is too vague for an agent to call this correctly without external knowledge.

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% for the two parameters 'query' and 'account', and the description does not mention or explain either one. The agent is left without any semantic guidance for these inputs, so the description completely fails to compensate for the schema gap.

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 states a specific operation ('Simulando as parcelas do acordo') and resource ('Acordos'), and includes the exact endpoint (GET /acordos/simularparcelas), so an agent can tell it apart from agreement list/put/desfazer siblings. It does not explicitly contrast itself with those siblings, but the verb and endpoint are 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?

'Obtendo dados para gerar o acordo' implies this should be used to fetch/simulate data before generating an agreement, which is a clear context. However, it provides no explicit when-to-use or when-not-to-use guidance and names no 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 indicate readOnlyHint=false and idempotentHint=false. The description adds the explicit '[write, altera dados]' signal, which usefully confirms mutation, but it does not disclose other behavioral aspects such as required authentication, what data is changed, or any side effects. This is adequate 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?

The description is a single compact sentence that front-loads the category and action, includes the endpoint, and flags mutation behavior. There is no wasted text, though the endpoint and write flag are somewhat redundant with the action and PUT verb.

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 parameter descriptions, and no usage guidance, the description is far from complete. An agent would know the tool adds tags, but would not know how to populate body, query, or account, what the response contains, or whether prerequisites exist. This is insufficient for reliable 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 input schema has three opaque string parameters (body, query, account) with 0% schema description coverage, and the description provides no explanation of what these parameters mean, what format they expect, or which are required. The description does not compensate for the schema gap at all, so the agent has no basis to construct a correct invocation.

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 states a specific action ('Adicionar etiquetas' / add tags) and a concrete resource via the endpoint PUT /arquivos/adicionaretiqueta, and situates it under 'Despesas / Etiquetas'. It is clear enough for an agent to understand the tool's function, and the action differentiates it from the remove-tag sibling, though it does not explicitly name sibling alternatives.

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?

There is no guidance on when to use this tool versus alternatives such as superlogica_arquivos_removeetiqueta or superlogica_arquivos_etiquetas. The description provides only a category and action, leaving the agent to infer invocation 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 already declare readOnlyHint=false and idempotentHint=false; the description's '[write, altera dados]' tag and HTTP method add only marginal confirmation of mutation. It does not disclose richer behavioral details such as file size limits, authentication requirements, or what happens on success/failure, but the annotation coverage lowers the bar.

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 compact sentence that front-loads the core action, includes the endpoint, and appends a mutation tag. Every word earns its place, with no filler or redundancy.

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 create operation with three undocumented parameters and no output schema, this description is not sufficient for correct invocation. It omits required field information, request structure, parameter semantics, and response details, leaving critical gaps for an agent trying to 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 input schema has three string parameters (body, query, account) with 0% description coverage, and the description provides no explanation of what these parameters mean or how to format them. The agent cannot infer the request body shape, the meaning of query, or the account field from 'Salvar novo arquivo'.

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 states a specific action ('Salvar novo arquivo'), a resource ('Documentos e Arquivos'), and the endpoint (POST /arquivos), making it clear this is the create operation for files. It distinguishes itself from list/update siblings reasonably well, though it does not explicitly name alternatives.

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 no guidance about when to use this tool versus siblings like superlogica_arquivos_put, superlogica_arquivos_list, or superlogica_arquivos_adicionaretiqueta. The word 'novo' implies creation, but there is no explicit context, prerequisite, or exclusion.

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, idempotentHit=true, and destructiveHint=false, covering the safety profile. The description adds the HTTP method and endpoint (GET /arquivos/etiquetas), which is useful but does not disclose richer behavioral details such as pagination, scoping, or rate limits. No contraction 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 one short, front-loaded sentence: domain, verb, and endpoint. Every element serves a purpose and there is 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?

The tool is simple and read-only, but with no output schema and no parameter descriptions, the description leaves uncertainty about the response format and what the two optional parameters control. An agent could invoke it correctly, but it would be guessing about filtering and return shape.

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 explain what 'query' or 'account' mean or how they affect the listing. The property names are somewhat self-evident but the description adds no parameter-level semantics, so it fails to compensate for the schema gap.

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 states a specific verb and resource: 'Listar etiquetas' with the endpoint GET /arquivos/etiquetas, and it specifies the domain 'Despesas / Etiquetas'. This clearly identifies the operation and distinguishes it from sibling tools like superlogica_arquivos_adicionaretiqueta and superlogica_arquivos_removeetiqueta.

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: use this tool when you need to list etiquetas. However, it does not explicitly discuss when to favor this over related tools or mention alternatives such as the create, update, or tag-management endpoints.

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, idempotentHint=true, destructiveHint=false, so the safe, read-only nature is already covered. The description adds the HTTP method (GET) and resource path, which is mild added context. It doesn't mention pagination, filters, or output shape, but for a list with annotations covering the safety profile 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 one short, readable line with the operation and endpoint. It earns its place and front-loads the verb. It is minimal to the point of being thin, but it is not padded.

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 large sibling set and zero parameter descriptions, the description is too thin. It does not clarify what 'arquivos' means in this domain, what query/account filter, or whether authentication is required via the authenticate tool. An agent can guess a basic listing call but has no context to handle edge cases or distinguish from similar list tools like superlogica_impressoes_list or superlogica_documentos_create.

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 explain what 'query' or 'account' mean. The description only says 'listar arquivos' but gives no parameter context beyond the schema's bare names. Since the schema provides no descriptions and the description does not compensate, an agent receives almost no guidance on how to populate these parameters.

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 states a clear verb and resource: 'Listar arquivos' (list files) via GET /arquivos/index. However, it doesn't explicitly differentiate from siblings like superlogica_arquivos_create or superlogica_arquivos_etiquetas; the 'list' verb distinguishes it partially, but the description doesn't call out its scope within the arquivos 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?

There is no explicit guidance about when to use this tool versus alternatives. The siblings include many arquivos operations, but the description merely names the endpoint. It implies a listing use case but provides no exclusions or conditions for when a different tool (e.g., create, put, add/remove tag) should be used.

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 [write, altera dados] tag only restates what annotation readOnlyHint=false already communicates; it adds no new behavioral detail such as side effects, required permissions, or error behavior. With no output schema and no further disclosure, the description adds little beyond 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?

The text is extremely brief and front-loads the operation, with no filler or redundant clauses. It loses the top score because it is a fragment and the [write, altera dados] tag duplicates annotation content instead of adding 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 tool with opaque string-only parameters and no output schema, this description is not sufficient for an agent to construct a valid request. It gives no format for body, no semantics for query, and no indication of what account refers to.

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 mentions none of the three parameters (body, query, account). Since all parameters are untyped generic strings, the description completely fails to explain what values should be supplied, making correct invocation nearly impossible.

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 states a concrete action ('Adicionar arquivo' / add file) and the HTTP endpoint (POST /arquivos/put), so an agent can tell it is a file-upload operation. It does not explicitly distinguish this from sibling tools like superlogica_arquivos_create, so it misses the top score.

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?

No guidance is given about when to choose this tool over the many sibling file operations, which operation it complements, or what prerequisites apply. The agent must infer usage from the endpoint naming alone.

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 notes '[write, altera dados]', which confirms the operation mutates data, and includes the PUT method. However, annotations already signal readOnlyHint=false, so the write nature is largely redundant. No additional behavioral context is provided, such as what data is changed, idempotence, or required authentication.

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 very compact and front-loads the domain and action. It contains no unnecessary words, though the extreme brevity sacrifices useful detail.

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 three undocumented parameters, no output schema, and sparse annotations, this description is far too incomplete. It does not explain what 'arquivos' refers to, how to structure the request, or what the response looks like, so an agent cannot reliably invoke 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?

Schema description coverage is 0%, and the description does not explain any of the three parameters (body, query, account). An agent would have no idea how to populate these fields, making correct invocation impossible without external 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 operation: 'Remover etiquetas' (remove labels) in the 'Despesas / Etiquetas' context, and includes the exact HTTP endpoint. It distinguishes itself from the sibling tool superlogica_arquivos_adicionaretiqueta through the verb 'Remover'.

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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The description only names the action; it does not explain scenarios or direct the agent to compare with related tools like superlogica_arquivos_adicionaretiqueta or superlogica_arquivos_etiquetas.

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 establish that this is a read-only, idempotent, non-destructive operation. The description adds the endpoint and the notion of a summary, but it does not disclose what the summary contains, how aggregation behaves, or what the response looks like. Some value is added beyond annotations, but behavioral detail is thin.

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 compact sentence that front-loads the domain category and the exact endpoint. It has no wasted words, though it sacrifices detail for brevity.

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 two undocumented parameters and no output schema, the description is incomplete. It should at minimum explain what query and account control and what the resumo response contains. As written, an agent cannot reliably construct correct calls or interpret results.

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 two parameters, query and account, with 0% description coverage, and the tool description does not mention or explain either parameter. The agent receives no semantic guidance for these parameters beyond their generic names.

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 (arrecadações resumo) and the HTTP verb GET, making it plain that this tool retrieves a collection summary. However, it mostly restates the tool name and does not distinguish it from sibling tools like superlogica_caixa_saldo or relatorios 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?

No guidance is given about when to use this tool versus alternatives. There are no exclusions, preferred scenarios, or mentions of related tools that would help an agent choose between this and other revenue/reporting 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 safe, non-mutating nature is covered. The description adds that this is a GET report of type W011A, but it does not disclose pagination, filtering behavior, or what the response contains. This is acceptable 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?

The description is a single compact sentence that front-loads the report code and endpoint. It is appropriately short, though the 'Relatórios:' prefix is slightly redundant with the report context.

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 and two completely undocumented parameters, the description does not provide enough context for an agent to reliably construct a valid request. The report type and endpoint are clear, but the meaning of query and account, likely important inputs, is missing.

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 two parameters, query and account, are plain strings with no schema descriptions. The tool description does not explain what these parameters mean, how they filter the report, or whether they are required in practice. The description fails to compensate for the complete lack of parameter documentation.

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

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

The description identifies a specific report code (W011A), its content (annual statement of revenues and expenses), and the exact endpoint (GET /balancetes/index). This is more specific than a generic 'list balance sheets' description, though it does not explicitly differentiate from the many sibling report tools beyond naming this particular report.

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 no guidance on when to use this tool versus alternatives such as superlogica_relatorios_list or the other relatorios_id_* tools. An agent is left to infer that this is the tool for W011A specifically, with no explicit context or exclusion 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the HTTP method and endpoint, but no additional behavioral traits such as pagination, filtering behavior, date-range handling, or authentication requirements. This is adequate 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?

The description is a single compact sentence that front-loads the domain and follows with the action and endpoint. There is no redundant wording or filler. It is appropriately sized, though the brevity comes at the cost of parameter and usage detail.

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 list tool with two optional but undocumented parameters and no output schema, the description is not complete enough for correct invocation. The agent still does not know what 'query' and 'account' expect, how results are returned, or whether results are paginated. The read-only annotations help, but they do not fill these 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 explain the meaning, format, or allowed values for 'query' or 'account'. Both parameters are bare strings with no required flag clarification. Since the description fails to compensate for the missing schema documentation, an agent cannot reliably construct correct arguments.

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 has a specific verb ('Listar') and a clear resource ('movimentações bancárias'), reinforced by the HTTP endpoint GET /caixa. The domain prefix 'Condomínios / Contas bancárias' adds context, and the resource differs from siblings like caixa_saldo. It clearly identifies what the tool does.

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 no guidance on when to use this tool versus alternatives such as superlogica_caixa_saldo, superlogica_contabancos_list, or superlogica_movimentacoesdiretas_create. There are no conditions, prerequisites, or exclusions, so the agent must infer the appropriate 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description is not the sole source of safety information. It reinforces read-only behavior through 'Obter' and 'GET', but adds little beyond the annotations and does not disclose error behavior, authentication needs, or response characteristics.

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 compact phrase that leads with the domain, states the action and resource, and includes the endpoint. Every part contributes useful information, with no filler or redundancy.

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 output schema and undocumented parameters, the description is too thin: the agent cannot determine accepted values for 'query' and 'account', how to select a specific account, or what the result looks like. The read-only annotations reduce safety concerns but not the operational ambiguity.

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 explain the 'query' or 'account' parameters. The phrase 'conta bancária' gives some context for 'account', but 'query' remains undefined, and the description adds almost no parameter-level meaning beyond the parameter names.

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 states a clear action and resource: 'Obter saldo de conta bancária' (get bank account balance), scoped to 'Condomínios / Contas bancárias', with the endpoint GET /caixa/saldo. It does not explicitly distinguish itself from sibling tools such as superlogica_caixa_list or superlogica_contabancos_list, so it stops short of a 5.

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?

No guidance is provided about when to use this tool instead of related account/balance tools, nor are prerequisites, exclusions, or alternatives mentioned. The domain label and GET endpoint imply a read-only balance lookup, but the agent is left to infer the appropriate invocation 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 explicitly tags the operation as '[write, altera dados]', which adds human-readable confirmation of the mutation behavior already implied by readOnlyHint=false. It also names the POST method. However, it does not disclose side effects beyond creating, auth requirements, or any reversible/irreversible details.

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 compact sentence front-loads the operation, endpoint, and behavior tag with no filler or repetition. Every segment adds 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?

The tool has three undocumented parameters and no output schema, yet the description provides no parameter semantics, no usage context, and no return-value expectations. For a new agent, calling this correctly would require guessing the body format. It is too sparse relative to the many sibling cobrança tools.

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 was expected to explain the three string parameters (body, query, account). It only implies via the endpoint that body likely carries the cobrança payload, but it never explains what each parameter is for, how they interact, or what format is expected.

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 states a specific verb ('Cadastrar') and resource ('nova cobrança') and includes the HTTP endpoint (POST /cobranca). It clearly identifies this as a create operation for charges, though it does not explicitly distinguish it from sibling cobrança tools like update, excluir, or estornar.

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?

No guidance is provided on when to use this tool over its many siblings. The description does not state conditions, prerequisites, or mention alternatives such as superlogica_cobranca_update or superlogica_cobranca_list. The only context is the 'Receitas' category label.

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 the tool as non-read-only, non-idempotent, and non-destructive. The description's '[write, altera dados]' reinforces mutation and is consistent with readOnlyHint=false, but adds little beyond the annotation; it does not describe side effects, auth requirements, or what happens to the charge's state.

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

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

The description is a single front-loaded sentence containing the domain, operation, resource, endpoint, and mutability marker. There is 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?

For a tool with no output schema, no parameter descriptions, and only sparse annotations, the description should compensate by explaining how to call it. It names the operation and endpoint but leaves the three parameters and invocation context completely unspecified.

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 three string parameters (body, query, account) with 0% description coverage, and the description does not explain any of them. An agent has no indication of what payload, query parameters, or account identifier are expected.

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 and resource: 'Cancelar invalidação de uma cobrança' (cancel invalidation of a charge), and adds the exact endpoint PUT /cobranca/desinvalidar. It is readily distinguishable from the sibling cobranca operations (create, estornar, excluir, liquidar, update, list).

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 usage situation is implied: use this tool when you need to undo an existing invalidation of a charge. However, there is no explicit guidance on when not to use it or how it relates to alternatives such as superlogica_cobranca_estornar or superlogica_cobranca_excluir.

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 readOnlyHint=false, and the description reinforces this with '[write, altera dados]' plus the PUT method. It does not disclose side effects, permission requirements, or reversibility, but it is consistent with annotations and adds a small amount of 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 short, front-loaded with the action and endpoint, and contains no filler. The terse style sacrifices informative content, but that is better evaluated under completeness rather than conciseness.

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 state-changing billing operation with three undocumented parameters and no output schema, the description is insufficient. It lacks request format, parameter meanings, and effect details, making correct invocation difficult.

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% for the three string parameters (body, query, account), and the description offers no explanation of any of them. An agent cannot determine what values to supply or how they map to the endpoint.

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 operation: 'Estornar uma cobrança' (reverse a charge), with a specific verb and resource, and includes the HTTP method and endpoint (PUT /cobranca/estornar). This distinguishes it from sibling charge operations such as liquidar, excluir, and desinvalidar.

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?

There is no guidance on when to use this tool versus related siblings like superlogica_cobranca_desinvalidar, superlogica_cobranca_excluir, or superlogica_cobranca_liquidar. The description only defines the action, leaving selection context entirely implicit.

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 convey readOnlyHint=false, and the description's '[write, altera dados]' essentially restates that this is a write operation. It does not disclose whether the operation is reversible, whether the charge is physically removed or merely marked as excluded, or what side effects occur. destructiveHint=false is not clearly contradicted because the operation may be a soft delete via PUT, but the description adds minimal behavioral depth beyond the annotations.

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

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

The description is a single sentence plus tags, making it very concise and front-loaded with the action. The trailing tags are somewhat redundant with annotations but do not hurt readability. It is appropriately short for a simple operation, though the brevity contributes to missing semantic context.

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 parameter descriptions, no output schema, and minimal behavioral disclosure, the description leaves essential invocation details unspecified. The agent must guess what to put in body and query and what account refers to. The description is insufficient for correct tool 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?

Schema description coverage is 0%, and the three parameters (body, query, account) are only typed as strings with no descriptions. The tool description does not mention any of these parameters or provide format expectations. An agent has no way to construct a valid request from this definition.

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

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

The description explicitly states the action 'Excluir uma cobrança' (delete a charge) and includes the endpoint 'PUT /cobranca/excluir', making the operation clear. The verb 'excluir' distinguishes it from sibling operations like 'estornar' or 'desinvalidar', though it does not name alternatives. It is a precise, actionable statement, even if it closely mirrors the tool name.

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?

No guidance is provided about when to choose this tool over sibling cobrança operations such as estornar, desinvalidar, or liquidar. The only contextual cue is the tag '[write, altera dados]', which merely indicates a write operation, and 'Receitas' (Revenue) suggests a domain but not selection criteria. An agent cannot determine the appropriate scenario from this description.

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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the GET method and the fact that the result is a download link. It does not disclose response format, error behavior, or what happens if parameters are missing.

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 that front-loads the core purpose and includes the endpoint. There is no filler or redundant content.

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 output schema and completely undocumented parameters, the description is too thin. It conveys the intended action but omits the parameter semantics and response details needed to invoke the tool confidently.

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% for the two parameters 'query' and 'account', and the description does not mention either parameter. The agent has no information about what these parameters mean or how to populate them, so correct invocation is essentially guesswork.

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 names a specific verb and object: 'Gerar link para download de 2a via de boleto' and gives the exact endpoint GET /cobranca/gerarlinksegundavia. This makes the tool's function clear. It does not explicitly contrast it with sibling cobrança tools, so it stops short of full 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 usage context is implied: use this tool when you need a second-copy boleto download link. However, there is no explicit guidance about prerequisites, when not to use it, or which alternative tool to select instead.

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=false, idempotentHint=false, and destructiveHint=false. The description adds the explicit [write, altera dados] tag and the PUT method, reinforcing the mutating nature without contradicting the annotations, but it provides no further behavioral context such as what data changes or whether the settlement is reversible.

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 compact sentence with tags, front-loading the action before the endpoint and write-nature tag. It contains no filler, though the [write, altera dados] tag is somewhat redundant with the annotations.

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 mutating tool with three undocumented generic parameters and no output schema, this description is too thin. It is missing how to identify the cobrança, which fields are required, the effects of settlement, and how it differs from the many cobranca_* sibling operations.

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 three parameters (body, query, account) are generic undecorated strings. The description offers zero parameter guidance, so an agent cannot know what payload identifies the charge to be liquidated. With 0% coverage, the description was obligated to compensate and did not.

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 states a specific verb+resource ('Liquidar uma cobrança') plus the HTTP endpoint (PUT /cobranca/liquidar) and domain category ('Receitas'). This makes it distinguishable from the many cobranca siblings (create, update, excluir, estornar, desinvalidar), though it does not explicitly name any alternative.

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?

No guidance is given on when to use this tool versus alternatives. It does not state that liquidar marks a charge as settled, nor contrast it with related operations like estornar (reverse) or desinvalidar, and no exclusions or prerequisites are 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context that this lists agreement compositions via a GET endpoint, which is consistent with the annotations. It does not add details about pagination, authentication, or response behavior, but the annotation coverage lowers the burden.

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 packs the domain category, purpose, and endpoint into a single line. It is a bit awkwardly structured with slash-separated labels, but it has no filler and front-loads the relevant context before the endpoint.

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

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

For a simple read-only list operation, the description gives the endpoint, purpose, and domain context. However, it omits any semantics for 'query' and 'account', and since there is no output schema it does not clarify what the returned 'compositions' look like or how they should be used to generate the agreement.

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 provides no explanation of the two string parameters, 'query' and 'account'. The description does not compensate for the missing parameter documentation, leaving the agent without meaningful guidance on how to fill these 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 states a specific action ('Listando composições do acordo') and identifies the resource via the endpoint ('GET /cobranca/index') and domain context ('Acordos'). It is clear enough to be recognized as a read-only listing tool for agreement compositions, though it does not explicitly distinguish itself from the similar sibling superlogica_acordos_list.

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 phrase 'Obtendo dados para gerar o acordo' implies the usage context: use this when needing data to build an agreement. However, it provides no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named despite many relevant siblings such as superlogica_acordos_list or superlogica_acordos_simularparcelas.

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 readOnlyHint=false, and the description reinforces this with '[write, altera dados]' and the PUT verb. It adds no deeper behavioral context such as what happens to existing data or whether the edit is partial or full, but there is no contradiction and the mutation semantics are sufficiently clear for a simple update.

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 short sentence with the endpoint and write tag, and the key verb-resource pair is front-loaded. It is concise with no fluff, though the '[write, altera dados]' tag is somewhat redundant with the verb 'editar'.

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?

There is no output schema, and the parameters are entirely undocumented. The description explains what the operation does but not what the body should contain, what query/account mean, or what a successful response looks like, leaving essential calling details missing.

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 gives no meaning to the three string parameters: body, query, and account. An agent has no information about what payload, query string, or account identifier to provide, making the tool effectively opaque.

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 states a specific verb ('Editar'), a resource ('cobrança'), and the HTTP endpoint (PUT /cobranca/update), which clearly identifies the operation. It distinguishes from sibling cobrança operations like create, liquidar, or excluir at a basic level, though it does not explicitly name them.

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?

There is no guidance on when to use this tool versus alternatives such as superlogica_cobranca_create or superlogica_cobranca_liquidar. The verb 'Editar' implies editing an existing charge, but no prerequisites, exclusions, or selection criteria are given.

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 '[write, altera dados]', which communicates that this is a mutating operation. This is consistent with readOnlyHint=false and adds a small amount of context beyond the annotations, but it does not disclose side effects, required permissions, or response 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 short and front-loaded, with the core action and endpoint in the first clause. The '[write, altera dados]' tag is compact and adds useful behavioral signal without padding.

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 create operation with three completely undocumented optional string parameters and no output schema, the description is far too sparse. An agent cannot reliably construct a valid request payload without additional documentation.

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 none of the three parameters (body, query, account) are explained anywhere. The description does not compensate for this gap, so an agent has no idea what values these parameters should take.

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 states a specific verb and resource ('Criar novo comunicado') and the HTTP endpoint (POST /comunicados), making the tool's purpose clear. It does not explicitly distinguish itself from the sibling superlogica_comunicados_notificarcomunicado, but the create-vs-notify action makes the distinction fairly obvious.

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?

No guidance is given about when to choose this tool over alternatives or about prerequisites. The description only states what the tool does; it does not mention the notify sibling or any 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 signal readOnlyHint=false and idempotentHint=false, and the description's explicit '[write, altera dados]' tag reinforces that this operation modifies data, which is consistent with the annotations. No further side effects, selection behavior, or response characteristics are disclosed, but the write intent is made clear.

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 with a short tag, front-loading the action and endpoint with no filler. The 'Comunicados:' prefix is slightly redundant with the resource, but the overall structure is compact and efficient.

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 that this is a mutation tool with no output schema, no required parameters, and three completely undocumented string parameters, the description leaves critical invocation details unstated. An agent would know what the tool does but not how to correctly populate body, query, and account, making reliable invocation unlikely.

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?

All three parameters (body, query, account) have 0% schema description coverage, and the description provides zero guidance on what any of them should contain. The description adds no meaning beyond the raw parameter names, so an agent cannot determine how to construct a valid request.

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 ('Disparar' — trigger) and a specific resource ('comunicados pendentes' — pending communications), and includes the exact endpoint POST /comunicados/notificarcomunicado. It is distinguishable from the sibling superlogica_comunicados_create because it targets pending notifications rather than creating records, though it does not explicitly name that alternative.

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: use this when you need to trigger pending communications. However, it provides no explicit when-to-use vs. alternatives, no prerequisites, and no exclusions, so an agent must infer the appropriate context from the action phrase alone.

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 the HTTP GET endpoint and the group-level scope, but does not disclose pagination, filtering behavior, or response shape.

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 compact, front-loaded sentence states the action, resource, and endpoint without filler. This is appropriately concise for a simple list 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?

With no output schema and two opaque optional parameters, the description provides only the bare minimum for a no-argument call. The agent lacks enough context to understand filtered invocation or the expected return data, so the definition is 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?

The input schema's 0% description coverage leaves 'query' and 'account' completely unexplained, and the description does not compensate by clarifying their meaning or usage. An agent cannot know what values to supply or whether they filter the listed groups.

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 concrete action ('Listar') and a specific resource ('grupos de condominios'), and includes the exact endpoint. This clearly distinguishes it from sibling tools like superlogica_condominios_get, which target individual condominiums rather than groups.

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?

No when-to-use or when-not-to-use guidance is provided, and no alternative tools are mentioned. The agent can infer that this lists condo groups, but there is no information about when to prefer it over related list/get tools or how to combine it with other calls.

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 '[write, altera dados]', which makes the mutating behavior explicit beyond the readOnlyHint=false annotation. It does not disclose more behavioral details such as required authentication, side effects, or validation failures, but the write nature is clear and consistent with 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 short, front-loaded, and contains only a few meaningful fragments: resource, action, endpoint, and write intent. It is not verbose, though it may be too sparse to convey full invocation details.

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 create operation with three undocumented string parameters and no output schema, the description is too thin. It gives a clear endpoint and intent, but lacks essential details about request body format, query parameters, account usage, and expected response.

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 provides no explanation of the three parameters (body, query, account). The endpoint hint is not enough to tell an agent what each string parameter should contain or when each is needed.

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 action ('Cadastrar novo condomínio'), the resource ('Condomínios'), and the HTTP method (POST /condominios). It also uses the word 'novo', distinguishing it from update or list operations among the sibling 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 implies this is for creating a new condominium, but it does not explicitly explain when to choose it over alternatives like update or get. There are no exclusions or explicit alternative references, only the expected create-verb 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description does not contradict them. It adds only the 'all' scope signal, with no detail on pagination, response shape, or how the query/account parameters modify the returned data. This is adequate but not enriching beyond the annotations.

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

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

A single compact sentence that front-loads the action, resource, scope, and endpoint with zero wasted words. Every element 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?

With two optional parameters and no output schema, the description leaves the meaning of both parameters and the return format unexplained. It is barely sufficient for a bare 'list all' invocation but insufficient for filtered or account-scoped calls, which the presence of query and account parameters implies are possible.

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 never explains the meaning of 'query' or 'account'. The weak implicit hint is the contrast between 'todos' (all) and the presence of optional parameters, suggesting they may filter results, but this is far from explicit. An agent cannot know how to populate either parameter correctly.

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 names a specific action ('Listar' — list), a concrete resource (condomínios/condominiums), the scope ('todos' — all), and an explicit HTTP endpoint. It is clearly distinguishable from the CRUD siblings superlogica_condominios_create and superlogica_condominios_update, though it relies on their names rather than explicitly naming them.

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?

No guidance is provided on when to use this tool versus the create/update siblings or any other alternative. There are no prerequisites, exclusions, or context cues about when listing all condominiums is the right call. The agent is left entirely to inference.

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=false, and the description mostly restates that with '[write, altera dados]'. It adds the PUT method but provides no extra behavioral context such as auth requirements, side effects, or which fields can be changed. There is no contradiction with 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 very short and front-loaded with the resource and action. The bracketed '[write, altera dados]' is slightly redundant with 'Editar', but the overall length is appropriate.

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 3-parameter update operation with no output schema and no parameter documentation, this description is far too thin. It gives the purpose but none of the request construction details needed to invoke the tool correctly.

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 none of body, query, or account are explained. The description says nothing about payload format, required fields, or how the identifier should be passed, so an agent cannot build a correct request.

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 states a specific action ('Editar dados condomínio') and the HTTP endpoint, clearly marking this as the update operation for condominium data. It is clear enough, but it does not explicitly compare itself to the create/get sibling tools, so it loses a point for missing 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 intended use is implied by 'Editar dados condomínio' — use it when editing existing condominium data. However, there is no explicit guidance about when to use it versus superlogica_condominios_create or superlogica_condominios_get, nor any prerequisites or 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 description explicitly marks the operation as '[write, altera dados]', which aligns with annotations (readOnlyHint=false) and confirms this is a mutating call. It adds the endpoint and the target domain, but it does not disclose side effects, required permissions, or what happens to existing values. This is useful but minimal context beyond the annotations.

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

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

The description is a single efficient sentence that front-loads the domain, action, and endpoint. There is no wasted text, though it is so brief that it omits essential parameter and usage details. It earns its place but at the cost of completeness.

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 write tool with three completely undocumented parameters and no output schema, the description is far too thin. It conveys intent but gives an agent no way to construct the request correctly, choose the right parameter values, or understand the response. This is materially worse than a tool with partially documented parameters.

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 three string parameters (body, query, account) with 0% description coverage and no enums. The description does not explain what any of these parameters mean, how they map to the condominium or configuration value, or what the request payload should look like. An agent cannot determine how to populate body, query, or account from this definition.

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 a specific verb and resource: 'Alterar valor de uma configuração específica de um condomínio' with the endpoint POST /configuracoes. This distinguishes it from sibling list tools, though the tool name 'create' versus 'alterar' creates slight ambiguity about whether a new configuration is created or an existing one is updated.

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?

No guidance is provided on when to use this tool versus alternatives such as superlogica_configuracoes_list, superlogica_configuracoes_list_get, or configuration-related tools. There are no stated prerequisites, exclusions, or context that would help an agent decide between this and related 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 description's 'Listar' and 'GET /configuracoes' are consistent with the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so there is no contradiction. It adds a little beyond the annotations — the exact endpoint and the per-condominium scope — but does not disclose pagination, what 'específicas' filters on, or authentication expectations. With annotations already covering the safety profile, a 3 is appropriate.

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 sentence that front-loads the domain, verb, resource, and endpoint with zero filler. Every word earns its place; there is no repetition of the tool name or the schema.

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 two fully undocumented optional parameters and no output schema, the description is too thin for an agent to call it correctly. It also leaves the relationship to superlogica_configuracoes_list_get unresolved. The annotations cover only the safety profile, not parameter semantics or return shape.

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% for the two parameters (query, account), so the description carries the burden of explaining them, and it does not. 'de um condomínio' only faintly implies that account selects the condominium, while query is entirely unexplained — an agent cannot determine what value to pass for either 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 states a clear action (Listar/List), a specific resource (configurações de um condomínio), and includes the HTTP endpoint (GET /configuracoes), so an agent knows what operation this performs. However, it does not distinguish this tool from its confusingly similar sibling superlogica_configuracoes_list_get, so it falls short of a perfect score.

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?

No guidance is given on when to use this tool versus alternatives such as superlogica_configuracoes_list_get or superlogica_configuracoes_create. There are no exclusions, prerequisites, or context beyond the 'Condomínios' domain prefix, so an agent must guess which list endpoint fits the situation.

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 the concrete HTTP endpoint and domain scope, which slightly reinforces the read-only behavior, but discloses no additional behavioral details such as pagination, return shape, or authorization requirements.

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 compact line with no filler words. It front-loads the domain area and the endpoint, making it efficiently scannable, though it is terse to the point of omitting useful context.

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 and read-only, but the description does not explain the two string parameters, does not distinguish it from its sibling list tool, and provides no context about what 'configuracoes' returns beyond 'boleto settings'. An agent could invoke it without required parameters, but cannot make informed filter decisions or understand the result scope.

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 carries the full burden for explaining the 'query' and 'account' parameters. It mentions neither, leaving the agent with no idea what values these parameters expect or how they affect the request.

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 states a specific resource ('Configurações de boletos em um condomínio') and an explicit endpoint (GET /configuracoes/index), making it clear this is a read operation for boleto configuration data. It does not differentiate itself from the sibling tool superlogica_configuracoes_list, which appears to cover the same general area, so it misses the top score.

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?

There is no guidance on when to use this tool versus sibling tools such as superlogica_configuracoes_list or superlogica_configuracoes_create. The description gives no context about filters, prerequisites, or conditions that would select this endpoint over 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 readOnlyHint, idempotentHint, and destructiveHint, so the description adds little behavioral context beyond stating the HTTP GET endpoint. It does not disclose pagination, filtering behavior, output format, or authentication requirements, and the description is consistent with 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 very short and somewhat front-loaded, but the 'Consumo:' prefix is largely redundant with the tool name and adds no value. It is concise but under-specified, leaving important semantic gaps.

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 output schema, no parameter descriptions, and no usage guidance, the description is too sparse to be fully actionable. It conveys only the basic resource and HTTP method, leaving an agent to guess at the intended values for 'query' and 'account'.

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

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

The input schema has two parameters, 'query' and 'account', with 0% description coverage, and the tool description gives no explanation of their meaning, format, or relationship. The description does not compensate for the schema's lack of parameter documentation at all.

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 clear verb and resource: 'Consulta de consumo' (consumption query) and specifies the endpoint 'GET /consumo/index'. This makes the tool's basic function understandable, though it does not explicitly contrast it with the sibling consumo_put_create and consumo_put_update 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?

No guidance is given about when to use this tool versus alternatives such as superlogica_consumo_put_create or superlogica_consumo_put_update. There is no mention of prerequisites, intended call patterns, or situations where a different consumption-related tool should be chosen.

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 readOnlyHint=false and destructiveHint=false. The description adds the explicit '[write, altera dados]' marker, confirming that the operation modifies data. This adds modest context beyond the annotations but does not disclose other behavioral traits such as authentication needs, side effects, or reversibility.

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 line that front-loads the resource, action, endpoint, and mutation flag. It contains no filler or redundant content, earning its place while remaining highly compact.

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 three undocumented parameters, no output schema, and no parameter descriptions, this one-line definition is insufficient. It lacks required request body composition, meaning of query and account, differentiation from the update sibling, and any indication of response or error behavior.

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 provides no explanation of body, query, or account. These are generic string parameters with no documented meaning, and the endpoint path does not clarify what payload is expected. An agent has no information about how to populate any of the three parameters.

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 states the action 'Inserir consumo' and the endpoint 'POST /consumo/put', making the resource and operation clear. It is recognizable as the create variant among the consumo sibling tools, though it does not explicitly differentiate itself from superlogica_consumo_put_update.

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 verb 'Inserir' implies this tool is for creating consumption records, and the sibling list shows both list and update alternatives. However, the description gives no explicit guidance on when to use this tool versus superlogica_consumo_put_update or superlogica_consumo_list. Usage context is only implied, not stated.

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

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

The annotations already signal a non-read-only operation (readOnlyHint=false), and the description's '[write, altera dados]' largely restates that in words. It adds the HTTP endpoint path, but no details about side effects, partial vs. full update, or consequences of calling it with different parameters. With annotations already covering the write nature, the description adds little beyond what is structured.

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 short and the key verb/resource appears first. The redundancy between 'edição' and 'altera dados' is minor, and the bracket tag is compact. Overall it is efficiently sized, though not as informative as it could be.

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 three undocumented parameters, no output schema, and no usage guidance, this description does not give an agent enough to call the tool correctly. There is no mention of required body format, expected response, or any prerequisites. For a mutating tool, this is severely incomplete.

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

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

The input schema exposes 'body', 'query', and 'account' as plain strings with 0% description coverage, and the tool description does not explain any of them. There is no meaning given for what the body should contain, how query is used, or what account refers to. Since the description does not compensate for the empty schema, parameters remain completely opaque.

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 the verb 'Edição' (edit) and the resource 'consumo', and gives the endpoint 'PUT /consumo/put', so an agent can determine the core operation. It does not explicitly contrast with siblings like superlogica_consumo_put_create or superlogica_consumo_list, but 'edição' plus the 'update' in the tool name make the distinction clear enough.

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 context about when to use this tool rather than the create or list siblings. No prerequisites, exclusions, or alternative conditions are stated. An agent must infer usage solely from the tool name and the generic verb 'edit'.

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 safe read-only nature is established. The description adds the GET endpoint and the bank-account domain scope, which is consistent with the annotations, but it does not disclose response shape, pagination, or authentication needs. This is some added context beyond the annotations, but not rich behavioral detail.

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 compact sentence, front-loaded with the domain and resource, followed by the endpoint. There is no fluff or redundant explanation, and every phrase contributes to basic understanding.

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

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

For a tool with two undocumented parameters and no output schema, the description leaves meaningful gaps: the semantics of query and account, what the response contains, and any filtering or pagination behavior. The domain and endpoint are clear, but an agent still lacks important information needed to invoke the tool correctly in nontrivial cases.

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 explain the 'query' or 'account' parameters at all. 'account' may be somewhat inferable from the resource, but 'query' is completely opaque. The description fails to add meaning beyond the bare schema property names.

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 'Listar' (to list) and a clear resource 'contas bancárias' (bank accounts), and adds the endpoint GET /contabancos/index. This makes the tool's purpose understandable, though it does not explicitly distinguish it from similar sibling list tools such as superlogica_list_accounts or superlogica_caixa_list.

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?

No guidance is given about when to use this tool instead of another sibling list tool, nor about what the query or account parameters should contain. The domain label 'Condomínios / Contas bancárias' implies a bank-account listing use case, but there are no explicit conditions, exclusions, or 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?

The description explicitly states '[write, altera dados]' and uses POST, confirming this is a mutating operation, which adds context beyond the readOnlyHint:false annotation. However, it discloses nothing about idempotency, side effects, or error behavior, so the added value is modest.

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: it gives the domain, action, endpoint, and mutability marker in one short line with no filler. The brevity is mostly a strength, though it leaves out important parameter context.

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 three completely undocumented parameters and no output schema, the description is insufficient for reliable invocation. The domain and endpoint help orient the agent, but essential details about how to construct the request are missing.

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 explain any of the three string parameters (body, query, account). An agent has no way to know what payload, query string, or account context is required to correctly invoke this tool.

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 ('Cadastrar') and identifies the resource ('dados de pagamento favorecido') plus the endpoint, making clear this tool creates favored-payment data in the expenses domain. It is distinguishable from the sibling list tool, though it does not explicitly contrast with it.

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

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

The description implies use when registering favored payment data, but it gives no explicit when-to-use guidance, no alternatives, and no prerequisites. With a large sibling list, the agent must infer when this tool is appropriate versus related 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 provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the endpoint and category, which is useful, but it does not disclose response format, pagination, authentication needs, or other runtime 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 a single compact sentence with no filler. It front-loads the category and includes the endpoint, which is useful, but it is slightly too sparse to fully carry the informational load.

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 and 0% parameter coverage, the description is incomplete for a tool that has two parameters. It does not explain how to construct a valid call or what the agent should expect in return. Annotations cover only the safety profile, not functional usage.

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 neither the description nor the schema explains what 'query' or 'account' mean. The description mentions no parameters at all, so an agent cannot tell whether 'query' is a search string, filter, or something else, nor whether 'account' is an ID, name, or code.

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 states the specific operation ('Listar dados pagamento favorecido') and the endpoint, making the resource unmistakable. It distinguishes the tool from its create sibling by the verb 'Listar.' However, it does not explicitly differentiate it from other list tools beyond the resource name.

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?

There is no guidance on when to use this tool versus alternatives such as superlogica_contatofavorecido_create or other list endpoints. The intended usage is only implied by the tool name and the bare statement, leaving the agent to infer 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 says the tool deletes a contact and includes '[write, altera dados]', yet annotations declare destructiveHint=false. This is an annotation contradiction: deleting a contact is inherently destructive. The description also does not disclose permanence, reversibility, or side effects beyond the contradictory write marker.

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 front-loads the operation, but the '[write, altera dados]' tag adds little value and the 'Unidades:' prefix is cryptic. It is concise but not optimally structured for agent consumption.

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 delete operation with three undocumented parameters and no output schema, this description is far from complete. It omits the required payload, authentication/account context, and any behavior details about the deletion. An agent cannot reliably invoke this tool without guessing.

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 three string parameters (body, query, account) with 0% description coverage, and the description adds no meaning about what these parameters should contain or which are needed to identify the contact. An agent cannot determine how to construct a valid call.

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 action 'Excluir um contato' (delete a contact) and the endpoint POST /contatos/delete, identifying both the verb and resource. It distinguishes this from other deletion tools by the explicit contact resource, though it does not explicitly position it against siblings.

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?

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites, conditions, or exclusions. The 'Unidades' prefix is unexplained and does not help an agent decide when this tool is appropriate.

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 annotation readOnlyHint=false already signals a write operation, and the phrase '[write, altera dados]' mostly restates that rather than adding new behavioral context. It does not explain side effects, authentication needs, file handling behavior, or what happens on success or failure.

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 compact line with the domain prefix, action, endpoint, and write indicator; it contains no filler or repetition. The most identifying information is front-loaded.

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 write tool with three undocumented parameters, no output schema, and almost no behavioral or usage context. Given only an endpoint and a generic schema, an agent has very little chance of invoking it correctly.

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 three parameters (body, query, account) are generic strings. The description does not say what each parameter means, what the request body should contain, or how files should be attached, leaving an agent unable to construct valid inputs.

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 names a specific action and resource ('Despesas: Anexar arquivos') and adds the HTTP endpoint POST /despesas/anexar, which makes the tool's role reasonably clear. It does not explicitly contrast it with sibling file tools such as superlogica_arquivos_create, so it falls just short of full 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?

There is no guidance on when to use this tool rather than the many expense/file sibling tools, and no mention of preconditions such as needing an existing expense or file payload. The only implied use case is attaching files to despesas, but no exclusions or alternatives are provided.

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 '[write, altera dados]' tag explicitly flags mutation, which aligns with readOnlyHint=false and is not contradictory. But it mostly repeats the annotation's implication rather than adding behavioral context; it does not disclose authentication needs, duplicate handling, idempotency, or side effects.

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 with the endpoint and mutation tag front-loaded. It is compact and scannable, though the 'Despesas:' prefix is mildly redundant with the tool name and family.

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 create operation with three undocumented parameters and no output schema, this description is incomplete. It provides the endpoint and confirms mutation, but leaves payload structure, parameter semantics, and expected response behavior unexplained.

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 gives no information about the 'body', 'query', or 'account' parameters. All three are opaque strings with no indication of required content or format, so an agent cannot construct a valid request payload.

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 action ('Cadastrar nova despesa') and the endpoint ('POST /despesas'), giving a specific verb and resource. However, it does not differentiate this tool from the sibling 'superlogica_despesas_post', which appears to target the same operation.

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?

There is no guidance about when to prefer this tool over the sibling 'superlogica_despesas_post' or related expense tools like 'superlogica_despesas_despesasrecorrente'. The phrase 'Cadastrar nova despesa' conveys the action but not selection criteria, exclusions, or prerequisites.

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?

A descrição afirma que a operação exclui/altera dados, mas as annotations marcam destructiveHint como false — contradição direta: excluir uma despesa é uma ação destrutiva. A tag '[write, altera dados]' apenas repete readOnlyHint=false e não acrescenta contexto sobre irreversibilidade, permissões ou efeitos colaterais.

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?

O texto é curto e a informação principal fica no início, mas o sufixo '[write, altera dados]' é redundante com as annotations e não agrega valor. É conciso, porém à custa de detalhes necessários.

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?

Sem output schema, sem descrição de parâmetros e sem contexto de uso, a definição é insuficiente para um agente invocar a ferramenta corretamente. Um DELETE em despesas exige pelo menos orientação sobre o que é excluído, se a ação é reversível e quais parâmetros são relevantes.

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?

O schema tem 3 parâmetros (body, query, account) sem descrições e a cobertura de descrição é 0%. A descrição da ferramenta não explica o formato esperado de body, o que deve ir em query, nem como account deve ser preenchido.

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?

A descrição informa explicitamente a operação ('Excluir despesa') e o recurso ('Despesas'), além do endpoint PUT /despesas/delete. Isso permite distinguir a ferramenta de despesas_create, despesas_list, despesas_estornar e despesas_liquidar, embora não aponte diretamente essas alternativas.

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?

Não há orientação sobre quando usar a exclusão em vez de alternativas como superlogica_despesas_estornar ou superlogica_despesas_liquidar. Também não há pré-condições, consequências ou casos de uso indicados.

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, idempotentHint=true, and destructiveHint=false, so the description is not required to restate safety. It adds the endpoint and the 'não lançadas' state, which is useful, but no additional behavioral traits such as filtering, pagination, or response format are disclosed.

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

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

The description is a single front-loaded sentence that immediately states the action, resource, and endpoint. Every element carries meaning and there is no 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 list tool with no output schema and undocumented parameters, the description is too thin. It omits parameter semantics, any mention of related tools, and any behavior beyond the endpoint, leaving important context for correct invocation missing.

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 'query' or 'account' at all. An agent is left without any semantic guidance for these two parameters beyond their raw string types.

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 names a specific action ('Listar') and a specific resource ('despesas recorrentes não lançadas') plus the exact endpoint. It is clear, though it does not explicitly differentiate itself from sibling listing tools like superlogica_despesas_list.

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?

No guidance is given about when to use this tool over alternatives such as superlogica_despesas_list or other despesas tools. The intended use is only implied by the resource name and 'não lançadas' qualifier.

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 this is not read-only, and the description adds only '[write, altera dados]', which roughly restates the same idea. No context is provided about what the reversal does to existing records, whether it can be undone, or any authorization or state requirements. With no contradiction to annotations but very little added behavioral detail, this falls short.

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

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

The description is a single, front-loaded sentence with no fluff: domain, action, endpoint, and a write-indicator are present. It is concise and scannable, evn though it lacks depth.

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?

Despite annotations and an endpoint, the tool still has three completely unexplained parameters and no output schema or behavior details. The description is not sufficient for an agent to construct a correct call, especially since 'body' likely needs structure and 'account' likely identifies the tenant.

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% and the description provides no information about 'body', 'query', or 'account'. All three parameters are undocumented strings, and required params is 0, so the agent has no way to know what to send. The description completely fails to compensate for the schema gap.

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 operation ('Estornar despesa' = reverse expense), the resource (despesas), and the HTTP endpoint (PUT /despesas/estornar). It is specific enough to distinguish this from siblings like superlogica_despesas_liquidar or superlogica_despesas_delete, but it does not explicitly explain what 'estornar' entails or contrast it with other reversal tools (e.g., cobranca_estornar).

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?

There is no guidance on when to use this tool versus the many sibling alternatives. No preconditions, prerequisites, or exclusions are mentioned. The agent is left to infer from the name and endpoint alone.

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=false, and the description's '[write, altera dados]' tag merely restates that same fact. The description does not disclose side effects, whether the operation is reversible via the estornar sibling, or what state the expense must be in to be liquidated. It adds almost no behavioral context beyond the annotations.

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

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

Three short fragments that front-load the purpose and include the endpoint with no wasted prose. The brevity, however, borders on under-specification rather than efficient completeness, since nothing beyond the basic action is conveyed.

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 three undocumented parameters, zero required parameters, and no output schema, the description omits everything an agent needs to invoke it correctly: parameter semantics, payload format, expected response, and differentiation within the large despesas sibling family. The agent is left guessing on essentially every decision.

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 none of the three string parameters (body, query, account) carries a description or is required. The description names the endpoint but never explains which parameter holds the expense identifier or what payload shape is expected, so an agent cannot construct a valid request from the available 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 states a concrete action and resource ('Liquidar despesa' — settle an expense) plus the exact HTTP endpoint (PUT /despesas/liquidar), so an agent can tell it apart at a surface level from sibling operations like delete, create, or estornar. However, it never defines what 'liquidar' actually entails (marking as paid? finalizing a status?), leaving room for interpretation.

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?

No guidance is given on when to use this tool versus the closely related despesas siblings, such as superlogica_despesas_estornar (to reverse a settlement), superlogica_despesas_delete, or superlogica_despesas_create. No prerequisites, ordering, or status conditions for the expense are 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 annotations already establish read-only, idempotent, and non-destructive behavior. The description adds the GET endpoint and period filter, but it does not disclose pagination, return format, authentication needs, or rate-limit 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 one compact sentence that efficiently includes purpose and endpoint. The leading 'Despesas:' label is slightly redundant with the resource name stated in the rest of the sentence, so it is not perfectly lean.

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

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

For a simple read-only list call, the description is nearly adequate, but the undocumented query/account parameters and the absence of an output schema leave gaps in what an agent needs to call it with full confidence.

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 for the undocumented 'query' and 'account' parameters. It mentions 'por período' but never maps that concept to either parameter, leaving the agent unable to infer how to format the request.

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 states a specific verb ('Listar'), a resource ('despesas'), a scope ('por período'), and the HTTP endpoint (GET /despesas/index). This clearly distinguishes it from the many sibling despesas tools that create, delete, estornar, or liquidar expenses.

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?

No guidance is given on when to use this tool versus the many despesas siblings, and no exclusions or prerequisites are mentioned. The context 'list by period' only implies usage rather than explicitly stating when this tool should be chosen.

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 annotation readOnlyHint=false already indicates this is not a read-only operation, and the description only restates this as '[write, altera dados]'. It adds no additional behavioral context such as required authentication, side effects, reversibility, or impact on related records.

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 technically front-loaded with the resource and verb, but it includes redundant tags like '[write, altera dados]' and a Portuguese category prefix. It is compact yet sacrifices useful 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?

With three undocumented parameters, no output schema, and no usage details, the description is not sufficient to call the tool correctly. It names the operation and endpoint but leaves the request construction and response behavior entirely unspecified.

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 explain the meaning, format, or required usage of 'body', 'query', or 'account'. An agent has no way to construct a valid request from this description.

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 action 'Editar despesa' (edit expense) and identifies the resource 'despesa' plus the endpoint PUT /despesas/post. This distinguishes it from sibling tools such as superlogica_despesas_create, though the endpoint suffix 'post' creates some ambiguity about the HTTP method.

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?

No guidance is given about when to use this tool versus alternatives like create, delete, liquidar, estornar, or list. With many closely related despesas siblings, an agent is left to infer the right 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 adds '[write, altera dados]', which confirms the mutation behavior and aligns with readOnlyHint=false. It does not contradict the annotations. However, it provides little else: no side effects, no authentication requirements, no return behavior, and no error conditions. The annotations already carry the basic safety profile, so this is adequate 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?

The description is very short and packed with useful signals: the resource category, the action, the HTTP endpoint, and the write/data-modification flag. Every phrase earns its place, and the key operation is clearly stated near the beginning.

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 three completely undocumented parameters, no output schema, and a large sibling list with similarly named create tools, the description is not sufficient for reliable invocation. It names the endpoint but leaves request construction and parameter semantics entirely unexplained. This is a functional gap for an agent.

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 provides no meaning for the three parameters: body, query, and account. It does not explain what the body should contain, how query is used, or what account refers to. The only weak implication is that body is the POST payload, but that is not sufficient for an agent to construct a correct request.

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 and resource: 'Inserir novo documento (POST /documentos)', which clearly identifies the operation. It also marks the tool as a write operation. However, it does not explicitly differentiate from siblings like superlogica_arquivos_create, and the 'Documentos e Arquivos' category leaves some ambiguity about scope.

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?

No guidance is given about when to use this tool versus alternatives. There is no mention of superlogica_arquivos_create or related document/file tools, no exclusions, and no conditions that would route an agent here instead of a sibling. The usage context must be inferred entirely from the endpoint name.

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, and the description's explicit 'GET' method is consistent with that safety profile, adding a concrete behavioral detail. However, it discloses nothing about pagination, filtering semantics, error behavior, or authentication, so beyond the endpoint and domain context it adds limited behavioral information. 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?

A single front-loaded sentence that immediately states the verb, resource, domain scope, and endpoint with zero filler. Every element earns its place and there is no redundancy.

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 read-only list operation with two optional parameters and no output schema. The description covers purpose and endpoint, and annotations cover the safety profile, but the meanings of query/account and the response shape remain undocumented. It is adequate for the simple case but has clear gaps.

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

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

Schema description coverage is 0%, so neither 'query' nor 'account' has an inline description, and the description text does not explain either parameter. The names are suggestive but ambiguous ('query' could mean search text or query parameters; 'account' is undefined). Because the description needed to compensate for the 0% coverage and did not, this dimension scores low.

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 names a specific verb ('Listar') and resource ('formas de pagamento'), and even includes the HTTP endpoint (GET /formasdepagamento), making the operation unambiguous. The 'Condomínios:' prefix scopes the domain. However, it does not explicitly differentiate this tool from sibling list tools (e.g., superlogica_cobranca_list), even though no sibling appears to duplicate the payment-methods resource.

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?

There is no guidance about when to use this tool versus alternatives, no exclusions, and no prerequisites or context conditions. The 'Condomínios:' prefix implies a domain scope but does not explain selection criteria or when another list tool would be more appropriate.

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 '[write, altera dados]' tag explicitly warns that the operation mutates data, which is useful beyond the readOnlyHint=false annotation. However, it does not disclose auth requirements, side effects, duplication behavior, or reversibility.

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 compact sentence with the domain, action, endpoint, and write warning front-loaded. It wastes no words, but the extreme brevity leaves the definition incomplete.

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 create tool with 0% parameter documentation, no output schema, and no usage guidance, the description is far too sparse to allow correct invocation. An agent would need substantial external knowledge to construct the request.

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% for body, query, and account, and the description does not explain any of them. An agent has no way to know what the body should contain, what query values are expected, or what account refers to.

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 states a concrete action ('Cadastrar favorecido') and the exact endpoint ('POST /fornecedores'), making the create operation clear. It is distinguishable from fornecedores_list and fornecedores_update, though the term 'favorecido' rather than 'fornecedor' introduces slight ambiguity with contatofavorecido_create.

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?

There is no guidance about when to choose this tool over list/update or the many similar create tools. The 'Despesas' prefix only implies a domain; it does not state prerequisites, alternatives, or 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 description aligns with the annotations: 'Listar' and 'GET' match readOnlyHint=true, idempotentHint=true, and destructiveHint=false. It adds the endpoint and domain context beyond the annotations, but does not disclose details such as authentication needs, pagination, or response behavior. 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 single compact phrase with no filler, and it front-loads the domain category and action. It is appropriately concise for a simple list tool, though it could still carry more useful detail without becoming verbose.

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 two undocumented parameters and no output schema, the description leaves important context missing: what 'query' and 'account' mean, whether they are optional filters, and what the returned list contains. The annotations cover safety but not invocation details.

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 'query' or 'account' parameters at all. The agent receives no additional meaning about what these parameters control or how they should be formatted.

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 states a specific verb ('Listar') and resource ('favorecidos'), and adds the endpoint 'GET /fornecedores/index' plus the domain context 'Despesas'. It is clear enough to identify the tool's function, though it does not explicitly differentiate it from similar list tools like superlogica_contatofavorecido_list.

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?

No guidance is provided on when to use this tool versus alternatives, such as superlogica_contatofavorecido_list or superlogica_despesas_list. The 'Despesas' prefix and endpoint give context, but there are no explicit usage conditions or 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?

As anotações já declaram readOnlyHint=false, idempotentHint=false e destructiveHint=false. A descrição adiciona a informação do endpoint 'PUT /fornecedores' e a indicação '[write, altera dados]', mas isso não vai muito além do que as anotações já comunicam. Não há detalhes sobre efeitos colaterais, exigências de autenticação ou o que acontece com dados existentes.

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 descrição é extremamente curta e direta, sem desperdício de palavras. Cada elemento (categoria, ação, endpoint e marcador de escrita) ocupa seu lugar. Porém, é tão mínima que carece de informações úteis, aproximando-se de subespecificação em vez de concisão ideal.

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?

Para uma ferramenta com 3 parâmetros não documentados, sem eschema de saída e sem orientação de uso, a descrição é completamente inadequada. Não informa o que deve ir no corpo, na query ou na conta, nem fornece contexto sobre o fluxo de edição de fornecedores. O agente não tem como invocar corretamente a ferramenta apenas com esta descrição.

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?

O eschema tem cobertura de 0% para descrição dos parâmetros, e a descrição da ferramenta não menciona nenhum dos parâmetros 'body', 'query' ou 'account'. Como a cobertura do eschema é muito baixa e a descrição não compensa de forma alguma, o agente não tem nenhuma orientação sobre o significado ou formato esperado dos parâmetros.

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?

A descrição 'Despesas: Editar favorecido (PUT /fornecedores)' identifica claramente a operação específica: editar um favorecido no contexto de despesas, usando o verbo 'editar' e o recurso '/fornecedores'. Isso a distingue das ferramentas irmãs de criação e listagem, como superlogica_fornecedores_create e superlogica_fornecedores_list, mesmo sem nomeá-las explicitamente.

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?

A descrição não fornece orientação explícita sobre quando usar esta ferramenta em vez das alternativas, nem menciona pré-requisitos, contexto de uso ou exclusões. O uso é apenas implícito pelo verbo 'editar', o que não é suficiente para orientar um agente entre as muitas ferramentas irmãs relacionadas, como create, list ou update de outras entidades.

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. The description adds a GET endpoint and domain context, which aligns with a read-only listing operation. However, it does not disclose return format, pagination, or any behavioral nuances, so it adds only modest context beyond the annotations.

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

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

The description is a single compact sentence that front-loads the domain and action, then provides the endpoint. There is no fluff or redundant wording; every element 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?

The tool lacks an output schema and has completely undocumented parameters. The description provides no clarification of what the response contains or what 'query' and 'account' mean, leaving important gaps for an agent trying to invoke it correctly. It is barely adequate for a parameterless call.

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

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

The input schema lists two parameters (query, account) but provides no descriptions (0% schema coverage), and the description does not explain them either. With no parameter guidance, an agent cannot know what values to pass or how they affect the result.

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 action ('Listar departamentos') and resource (departments/user groups), and places it in the 'Solicitações (Tickets)' domain. It also includes the exact endpoint. While it doesn't explicitly contrast with sibling tools, the resource and domain make its purpose reasonably distinct from tools like superlogica_tickets_list.

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?

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or typical scenarios. The description only states what it does, leaving the agent to infer when it is appropriate.

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 '[write, altera dados]' tag is consistent with readOnlyHint=false and confirms the operation mutates data, but this mostly duplicates annotation info. The POST endpoint is useful extra context, yet side effects, required permissions, and failure behavior are not disclosed.

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 compact and front-loaded with the action, and the tags are not wasteful. It could be slightly more informative without harming conciseness, but the current wording has no 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 create operation with three undocumented string parameters and no output schema, this description is far too thin. It omits the request payload shape, required fields, and typical usage examples, leaving the agent to guess how to invoke the tool correctly.

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?

Input schema has 3 parameters (body, query, account) with 0% schema description coverage, and the description provides no explanation of any parameter. An agent cannot infer what values should go in body, query, or account or whether they are required.

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 names a specific action ('Criar agendamento' - create scheduling) and resource ('historicocobranca'), reinforced by the HTTP verb POST and path. The create verb clearly distinguishes it from sibling list/update tools for the same resource.

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 no guidance on when to use this tool versus alternatives such as superlogica_historicocobranca_update or list. The 'create' wording implies usage for new appointments, but no explicit context or exclusions is provided.

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 no behavioral context beyond what the annotations and the verb 'Listar' already imply, such as pagination, filtering behavior, authentication requirements, or response characteristics.

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 front-loaded, with a single clear sentence and the endpoint included as helpful context. It is not bloated, though it is terse to the point of omitting important usage and parameter details.

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 listing tool with two undocumented parameters and no output schema, the description is not complete enough for reliable invocation. The agent knows what resource is being listed but cannot determine how to filter or scope the request, nor what result to expect.

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% for the two parameters ('query' and 'account'), and the description does not explain what either parameter means or how they affect the listing. The description entirely fails to compensate for the schema gap, leaving an agent without the information needed to construct a correct invocation.

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 states a specific verb ('Listar') and resource ('históricos de Cobranças'), with the endpoint GET /historicocobranca/index. It is clear enough to identify the operation, though it does not explicitly differentiate itself from sibling tools like superlogica_cobranca_list.

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 versus alternatives such as superlogica_cobranca_list, superlogica_historicocobranca_create, or superlogica_historicocobranca_update. No context is given about the relationship between 'cobranças' and 'históricos de cobranças'.

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 'write, altera dados', which is consistent with annotations (readOnlyHint=false) and states that this is a data-modifying operation. But beyond that, it does not disclose side effects, required permissions, or what happens to the existing schedule. 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 single, front-loaded sentence with the action, endpoint, and a behavior tag. It is compact and readable, though the '[write, altera dados]' tag partly duplicates what the annotations already convey.

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 three undocumented parameters and no output schema, the description is too sparse to let an agent construct a valid update request or understand the response. It explains what the tool does but not the necessary request details or expected behavior beyond the edit itself.

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 compensate by explaining the body, query, or account parameters. An agent cannot determine what payload structure is expected for editing an agendamento from the description alone.

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 states a specific action ('Editar agendamento') and resource ('PUT /historicocobranca'), and gives the domain ('CRM de Cobrança'). It is clear that this tool updates a billing schedule, though it does not explicitly contrast itself with sibling create/list 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 word 'Editar' implies this is for editing an existing schedule rather than creating or listing one, and the PUT method reinforces that. However, there is no explicit guidance about when to prefer this tool over sibling tools like superlogica_historicocobranca_create or superlogica_historicocobranca_list.

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 only the endpoint and category 'Despesas'; it does not disclose pagination, response shape, or filtering behavior beyond what annotations imply.

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 compact sentence with the scoping category and endpoint front-loaded. It is concise and contains no filler, though it is brief to the point of omitting useful context.

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 two undocumented parameters and no output schema, the agent cannot understand how to filter or what the response will contain. The annotations cover safety, but the description leaves important operational context missing, so the tool is not fully usable based on the definition alone.

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 gives no hint about what 'query' or 'account' mean or how they affect the list result. Since the schema does not document the parameters and the description does not compensate, the agent has no semantic basis for using them.

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 states a specific verb ('Listar'), a resource ('imposto'), and the HTTP endpoint ('GET /impostos'), making the core purpose clear. However, it does not distinguish this tool from closely related siblings such as 'superlogica_despesas_list' or explain what 'impostos' means in this domain.

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