EasyJur

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

The description discloses the authentication workflow, including browser login, token capture, and two connection modes. It adds context beyond the annotations (idempotent, non-destructive) by explaining that it creates a session or permanent connection. 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 two sentences long and information-dense. It front-loads the core purpose and alternates between setup methods efficiently, but could be slightly more concise by trimming redundant phrasing like 'MCP.AI for IDE agents (Cursor, etc.).'

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

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

For a single-parameter tool with no output schema, the description covers the authentication process, both usage modes, and token handling. It does not explicitly state what the tool returns (e.g., a success message or link), but implies the output (the link for login when no token is provided), leaving minor 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?

With 0% schema description coverage, the description fully explains the 'token' parameter: it can be passed as a JWT for session login, or omitted to receive a link. This adds meaning beyond the bare schema, though it does not specify the exact format or validation rules.

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

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

The description clearly states the tool's purpose: authentication for MCP.AI IDE agents, with a specific verb (login) and resource (access token). It is distinct from sibling tools like 'connect' and 'easyjur_get_token' by detailing the browser login flow and token handling.

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 provides explicit usage instructions with two scenarios: permanent config-based header vs. session-only token paste. It clearly states when to use each approach ('Best' vs. 'Or'), but does not explicitly mention alternatives like 'easyjur_get_token' or when NOT to use this tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond annotations by explaining conditional response states (authenticated:true vs connect_url) and what triggers each state, painting a fuller picture of the tool's behavior.

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

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

Two compact sentences convey the core behavior and key conditional results without unnecessary words. The main purpose is front-loaded, and every clause adds meaningful information.

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

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

For a zero-parameter, read-only status tool with no output schema, the description covers the essential states (all providers connected vs missing credentials) and what the response contains. The tool is simple, and the description is sufficient for an agent to know what 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?

The tool has zero parameters and schema coverage is 100% (empty properties), so there are no parameter semantics to explain. The baseline of 4 applies for no-parameter tools, and the description correctly avoids discussing 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 clearly states the tool's function: 'Returns connection status and URLs.' It provides specific conditional outcomes (authenticated:true with empty pending[] vs connect_url for missing credentials), which distinguishes it from siblings like authenticate and easyjur_api_status.

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

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

The description implies when to use the tool (checking connection status), but it does not explicitly state when not to use it or mention alternatives like authenticate or easyjur_api_status. Usage context is inferred rather than directly 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description adds no behavioral context beyond that. It does not mention return shape, empty-result behavior, pagination, or any special handling of the 'query' parameter, so beyond annotations there is zero transparency.

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 no filler, so it is concise. However, it is more under-specification than effective conciseness: it restates the tool name and offers no structured or useful 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?

With a nested 'query' parameter and no output schema, the description should clarify expected inputs and return values; it does neither. The minimal phrase may suffice for a trivial tool, but given the ambiguous query param and the large sibling set, it is not complete enough for reliable agent selection and 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 description provides no parameter explanations. The required 'id_agenda' is only inferable from the tool name, and the optional 'query' object is completely unexplained. The description fails to compensate for the missing schema-level 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 'Comentários de um item de agenda' is essentially a Portuguese restatement of the tool name; it identifies the resource but lacks an explicit verb or operation (e.g., 'list', 'get', 'retrieve'). It does not meaningfully distinguish this tool from similar agenda-related siblings like easyjur_agenda_envolvidos or easyjur_agenda_etapas.

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 easyjur_get_agenda, easyjur_agenda_etapas, or easyjur_agenda_envolvidos. There are no stated preconditions, exclusions, or selection 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 clearly indicate read-only, idempotent, and non-destructive behavior. The description does not add extra context but does not contradict the annotations, so transparency is adequate.

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

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

The description is extremely concise—two short sentences with no redundant information. It is well-structured and gets straight to the point.

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

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

While the purpose is clear, the description lacks important context such as what 'envolvidos' specifically refers to (e.g., people, roles), expected output format, or any usage caveats. The minimal information may leave an agent unsure about the return value or edge 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?

The parameters 'agenda_id' and 'agenda_ids' are self-explanatory from their names, but 'query' is ambiguous and no descriptions are provided. The description does not clarify the meaning or usage of any parameter, leaving room for confusion.

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

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

The description clearly states that the tool retrieves involved parties for an agenda item, distinguishing it from sibling tools like comments or stages. The verb 'Envolvidos' implies a retrieval action, making the purpose specific and 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?

No guidance is provided on when to use this tool versus alternatives. The only usage hint is the bulk support for multiple agenda_ids, but it does not clarify scenarios or prerequisites for using this tool over others.

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 value by disclosing the bulk execution capability (agenda_ids), which is a behavioral trait not inferred from annotations. No contradictions exist, though return format and other quirks are not covered.

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

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

The description is extremely concise: two short sentences, each adding meaningful information. The purpose is front-loaded, and the bulk support note is relevant. There is no redundancy or fluff.

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

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

For a tool with 3 parameters (including a nested 'query' object), no output schema, and moderate complexity, the description is too sparse. It does not explain the return shape, the purpose of the 'query' parameter, or how single vs. multiple agenda IDs should be used. Annotations cover safety, but not functional completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It only clarifies the 'agenda_ids' parameter for batched execution, while ignoring the 'query' object parameter and the relationship between 'agenda_id' and 'agenda_ids'. This is insufficient for a 3-parameter tool with nested objects.

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 specific resource ('workflow stages of an agenda item') and is distinct from sibling tools like easyjur_agenda_comentarios or easyjur_agenda_envolvidos. However, it lacks an explicit action verb such as 'get' or 'list', relying on the readOnlyHint annotation to imply retrieval.

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 bulk support note ('accepts agenda_ids for batched execution') gives a conditional usage hint, but there is no explicit guidance on when to prefer this tool over alternatives like easyjur_get_agenda or easyjur_list_agenda. No exclusions 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 adds useful context beyond those annotations by specifying that the status includes identity and limits for the authenticated office. No contradiction exists.

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

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

The description is a single, concise sentence that directly conveys the tool's purpose and scope. There is no padding, redundancy, or unnecessary 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?

The tool appears simple and annotations cover safety and idempotency, but there is no output schema and the optional query parameter is completely undocumented. The description gives the core idea but does not fully explain request usage or return-format expectations.

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

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

The schema has one optional 'query' object with no property descriptions and schema description coverage is 0%. The description provides no information about what this query object should contain or how it affects the request, leaving the agent without meaningful parameter semantics.

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

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

The description clearly states that the tool reports the API status of the authenticated EasyJur office, with identity and limit information. This is specific about the resource (EasyJur API status for the authenticated office) and distinguishes it from sibling tools like easyjur_get_token or easyjur_get_user.

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

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

The description provides clear context: use this tool to check the API status, identity, and limits of the authenticated office. It does not explicitly mention when not to use it or name alternatives, but the intended use is clear enough for a status-check tool.

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

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

Annotations indicate destructiveHint=false and readOnlyHint=false, implying this is a creation tool. The description states it 'cria' (creates) which aligns with the annotations. However, it does not disclose potential side effects such as automatic movements or duplicate creation risks, but annotations already cover the basic safety profile, so a score of 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?

The description is extremely concise, using two short sentences. It front-loads the core action and required fields, and all information is relevant. Every word earns its place.

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

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

Given the tool's complexity (12 parameters, nested objects, no output schema), the description covers the essential usage (required fields, optional process linkage) but does not explain optional parameters like 'data', 'hora_inicio', etc. However, the schema provides parameter names, and the core behavior is sufficiently described for an AI agent to select and invoke the tool. A score of 4 is appropriate.

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 12 parameters with 0% description coverage. The description names two required parameters (tipo, id_advogado) and explains the purpose of 'processo' (to link to a case for movement recording). This adds significant value beyond the schema, compensating for the lack of per-parameter descriptions, but it does not cover all 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 clearly states the tool's purpose: 'Cria item de agenda' (Creates an agenda item), and specifies required fields. It also explains the optional linkage to a process ('Vincule a um processo...') which distinguishes it from related list/get 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 explicitly states when to use the tool by listing required parameters ('Obrigatórios: tipo, id_advogado') and provides a conditional use case ('Vincule a um processo... para registrar uma movimentação/atualização'). This gives clear context without mentioning alternatives, but the alternatives are obvious from sibling tools like easyjur_get_agenda or easyjur_list_agenda.

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 minimal behavioral info beyond 'creates'. Annotations indicate it is a write operation (readOnlyHint=false) but not destructive, which the description reinforces by the word 'cria'. However, it doesn't disclose what happens on success (e.g., returns created object), error conditions, or side effects. Since annotations already provided the safety profile, this adds little.

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 to the point, consisting of a single clear sentence. It lists required fields succinctly. However, it lacks structured sections, examples, or format guidance. Still, it conveys the essential information with minimal fluff.

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

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

The description lacks important context: what the tool returns, error conditions, validation rules, or any behavior beyond creation. It doesn't mention the data source or system it operates on, nor provide any guidance on integration with other tools. The minimal information leaves the agent guessing about the outcome 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 required fields are listed (nome, status, responsavel, cliente), but there are no descriptions for any parameter. The schema shows types (string/number) but for a create operation, it's unclear what format 'status' should take (e.g., is it a number code or string?), what 'cliente' expects (ID or name?), or what 'extra' contains. Optional fields like 'valor_total' and 'data_atendimento' are unexplained.

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

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

The description clearly states the tool's purpose: 'Cria oportunidade' (creates opportunity). It identifies the action as creation, which distinguishes it from get/list tools. However, it doesn't explicitly differentiate from other create tools like create_processo or create_pessoa, but the resource is named.

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

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

The description mentions required fields but gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or context. It doesn't say when not to use it or what scenarios it's best suited for.

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á indicam que não é read-only, não é idempotente e não é destrutiva. A descrição apenas repete a ação de criação sem adicionar informações sobre efeitos colaterais, duplicidade, autorização ou formato de retorno. Não contradiz as anotações, mas também não adiciona contexto relevante além do que já é fornecido.

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 concisa: duas frases, sem excesso de palavras, direto ao ponto. O conteúdo essencial é apresentado sem redundância.

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 de criação com 8 parâmetros e sem schema de saída, a descrição é insuficiente. Não menciona o formato de resposta, efeitos colaterais, ou qual combinação de parâmetros opcionais é válida. A falta de orientação sobre como usar campos como cpf/cnpj e fisica_juridica juntos é uma lacuna crítica para o agente.

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?

A cobertura de descrição de parâmetros é 0%. A descrição apenas repete os campos obrigatórios (nome, fisica_juridica) que já estão no schema. Não explica o significado de parâmetros como cpf, cnpj, email, ou a relação entre fisica_juridica e cpf/cnpj. Não adiciona nenhum valor semântico além do que o schema já possui.

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?

O título 'Cria uma pessoa' é um verbo específico + recurso, claro e distinguível dos irmãos get/list. Estabelece explicitamente que é uma operação de criação e menciona os campos obrigatórios, o que diferencia de ferramentas de consulta.

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?

O contexto de criação é óbvio, pois todos os irmãos são de consulta (get/list). No entanto, não há menção a pré-requisitos como autenticação ou quando não usar. A orientação é implícita, mas o nome e a descrição já deixam claro o propósito.

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 non-read-only, and the description aligns with that. It adds a behavioral note about the absence of an update method and suggests an alternative for movements, which is useful. However, it does not describe success/error behavior, idempotency, or side effects beyond creation, though the annotations reduce 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 concise, consisting of two sentences. It clearly states the purpose, lists required fields, and includes a practical caveat in parentheses. There is no redundancy or ambiguity, making it well-structured and easy to parse.

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 core action (create a process) is covered, and the caveat about update and agenda adds context. However, the description does not explain the full parameter set or return behavior, and it lacks details about the meaning of the process fields. It is adequate but not fully comprehensive for a tool with 8 parameters and no output schema.

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 missing parameter explanations. It only lists the required parameters (numero, id_advogado) without defining them, and the optional parameters (id_cliente, titulo_acao, etc.) are not mentioned. Given the low coverage, this is insufficient to help an agent understand what values to provide.

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 ('Cria um processo' - Creates a process) and identifies the resource. It also distinguishes itself from other tools in the sibling list by explicitly mentioning required fields and providing a caveat about the lack of update functionality, making its purpose unambiguous.

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

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

The description provides some usage context by noting that the official API has no update and directing users to easyjur_create_agenda for registering movements. However, it does not explicitly contrast with list/get or other creation tools, though the verb 'Cria' implicitly indicates when to use it. The guidance about alternatives is helpful but not exhaustive.

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 the behavioral detail that it supports batch execution via 'agenda_ids', which is not captured by annotations. However, it does not disclose other behaviors like error responses or lack of filtering options.

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 to the point, with two sentences that front-load the core purpose and then mention the bulk feature. Every sentence contributes value, 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?

Given this is a simple get-by-ID tool with no output schema, the description should at least clarify what the response contains and how the 'query' parameter is used. It does not address these, leaving the agent with gaps in understanding. The bulk support mention is brief and lacks usage details. Overall, the description is minimal and insufficient for full operational clarity.

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 0% description coverage, so the description must compensate. It explains that 'agenda_id' identifies the item and that 'agenda_ids' enables batched execution, giving meaning to two of three parameters. However, it completely ignores the 'query' parameter, leaving its purpose unexplained, so compensation is 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 description clearly states the action ('Busca um item de agenda') and the resource (agenda item) with the primary parameter (by ID). It distinguishes from the sibling 'easyjur_list_agenda' by indicating this is for fetching a specific item, not listing all. The verb 'Busca' and the phrase 'por ID' make the purpose unambiguous.

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

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

The description implies use when you have an ID and want a single agenda item. It does not explicitly mention when not to use this tool or mention alternatives like 'easyjur_list_agenda' for bulk listing. The bulk support note is useful but does not guide scenarios where to choose this over list 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, covering the safety profile. The description adds meaningful behavioral context by disclosing bulk execution via despesa_ids, which is not evident from the annotations or schema alone. It still omits return-format or error behavior, 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 two succinct sentences with no filler. The primary action is front-loaded, and the bulk-support detail is a single additive clause. Every word earns its place.

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

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

For a simple read-only get-by-ID tool, annotations cover safety, making the description reasonably adequate. However, the query parameter is undocumented, and there is no mention of return values or error handling, leaving the agent with some uncertainty when invoking the tool with anything other than a plain ID.

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 must compensate. It clarifies despesa_id as the search identifier and despesa_ids as the batch input, but it completely ignores the query parameter, which remains unexplained. This makes the parameter guidance partial rather than complete.

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

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

The description clearly states the tool's function: 'Busca uma despesa por ID' (searches for an expense by ID), using a specific verb and resource. This distinguishes it from list-oriented siblings like easyjur_list_despesas and from other get-by-ID tools targeting different resources. The added bulk support detail further clarifies its purpose.

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

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

The description implies usage when a despesa_id or despesa_ids are available, and the bulk support note adds a usage condition. However, it does not explicitly state when to prefer this tool over alternatives, such as easyjur_list_despesas for unfiltered searches, nor does it mention 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 clear. The description adds the bulk execution capability, which is useful. It does not describe return format or error behavior, but with annotations covering the safety aspects, 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?

The description is very concise: two short sentences. It front-loads the primary purpose and adds the bulk support note. No wasted words, though it could be slightly more informative about parameters.

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

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

Given the tool has 3 parameters with 0% schema coverage, no output schema, and nested objects, the description is insufficient. It does not explain the 'query' parameter, return structure, or any edge cases. For a simple get-by-ID tool, it's adequate for the main use case but incomplete for full understanding.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'grupo_id' and 'grupo_ids' but does not explain the 'query' parameter at all. The description adds minimal value beyond the schema, leaving the 'query' parameter's purpose unclear. This is a significant 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 states the tool's purpose: 'Busca um grupo por ID' (searches for a group by ID). It also mentions bulk support via 'grupo_ids', which adds specificity. However, it doesn't explicitly distinguish from sibling tools like easyjur_list_grupos, though the 'by ID' scope implies a difference.

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 have a specific group ID to fetch, and mentions bulk support. It does not explicitly state when not to use it or mention alternatives like easyjur_list_grupos for listing all groups. The guidance is minimal but not misleading.

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?

With readOnlyHint=true, idempotentHint=true, and destructiveHint=false, the safety profile is already covered. The description adds a useful behavioral fact—bulk execution via oportunidade_ids—but does not go further into response details, error behavior, or how the batch interacts with required fields.

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 only two sentences, front-loads the core purpose, and adds the batch detail without fluff. Every part 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 no output schema and low parameter coverage, the description leaves important gaps, including the role of `query`, how to combine `oportunidade_id` and `oportunidade_ids`, and what a batched request response may look like. It is minimally usable for the simple case but incomplete for full 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%, so the description must compensate. It only explains that `oportunidade_ids` enables batch execution, while the `query` parameter is completely unexplained and the required field `oportunidade_id` creates ambiguity when `oportunidade_ids` is also provided.

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

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

The description uses a specific verb-resource pair ('Busca uma oportunidade por ID') and clearly distinguishes the singular fetch operation from list/create/get sibling tools. The bulk-support note further clarifies this tool's scope beyond a simple get.

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

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

The description clearly implies the tool is for retrieving a single opportunity by ID, optionally batched. It does not explicitly state when to prefer this over list_oportunidades or how to choose between single and bulk, but its contextual use case is obvious.

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 read-only, idempotent, and non-destructive behavior. The description adds useful context about batched execution through pessoa_ids, but does not disclose response shape, error behavior, authorization requirements, or the behavior of the query parameter.

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 concise: two short sentences, the first immediately states the core purpose and the second adds the bulk behavior. There is no redundant or filler text.

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

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

The core read-by-ID behavior is well covered and the annotations support the safety profile. However, with an undocumented nested query parameter and no output schema, the description leaves meaningful gaps that may require the agent to guess about query usage and response expectations.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies that pessoa_id is the lookup key and that pessoa_ids enables batched execution, but it leaves the nested query parameter completely unexplained and adds no detail about value formats or constraints.

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

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

The description clearly states the tool fetches a person by ID, using a specific verb and resource. This distinguishes it from sibling tools like easyjur_list_pessoas and easyjur_create_pessoa, and the bulk-support note adds further operational clarity.

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 ID-based lookup usage is implied by the description, but there is no explicit guidance about when to prefer this over alternatives like list_pessoas or when not to use it. No alternatives are named and no exclusion 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds 'complete data' and bulk execution context, but it does not disclose result shape, error behavior, or any response details. 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 only two sentences: the first front-loads the core purpose, and the second adds bulk behavior. No filler or redundant restating of the tool name.

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 no parameter descriptions, the definition should provide more context about the return payload and the role of 'query'. It states 'dados completos' and bulk support, which is enough for a simple get-by-ID tool, but the unresolved query parameter keeps it from being 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 has 0% description coverage, but the description partially compensates by explaining processo_id ('by ID') and processo_ids ('bulk support'). However, the 'query' parameter is left completely unexplained, and the relationship between required processo_id and optional processo_ids is ambiguous.

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 'Busca um processo por ID (dados completos)' uses a specific verb ('busca'), names the resource ('processo'), and clearly specifies retrieval by ID with full data. This differentiates it from siblings like easyjur_list_processos and other easyjur_get_* 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?

'Bulk support: accepts processo_ids for batched execution' gives concrete guidance on when to use the bulk parameter. It does not explicitly exclude alternatives, but the get-by-ID vs. list distinction is clear from the name and 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 declare readOnly, idempotent, and non-destructive behavior, so the description does not need to restate those. It adds useful context about bulk execution via receita_ids, but does not explain response shape, error behavior, or any constraints on batched calls.

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

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

The description is extremely concise: one clear main sentence plus a short bulk-support note. Every sentence adds value 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?

For a simple ID-based getter with read-only annotations, the description covers the primary and bulk use cases adequately. However, the unexplained `query` parameter and the absence of any return-value or error information leave notable gaps, especially without an output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies the purpose of receita_id ('por ID') and receita_ids ('bulk support'), but completely ignores the `query` parameter, which remains ambiguous despite being a nested object in the schema.

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

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

The description uses a specific verb ('Busca' = fetches) with a clear resource ('uma receita') and identifier ('por ID'), making the tool's purpose unambiguous. It also differentiates itself from sibling listing tools like easyjur_list_receitas by focusing on ID-based retrieval.

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 'por ID' implies the tool should be used when the agent already has a specific receita ID, and the bulk-support note suggests using receita_ids for batched operations. However, it gives no explicit guidance on when to prefer list_receitas or how to choose between single and bulk modes beyond the parameter names.

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 value by disclosing bulk execution behavior through the ids parameter, a non-obvious behavior beyond the annotations. It does not detail response shape or batch limitations, but the annotation bar is lower.

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

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

The description is two short sentences, front-loaded with the core purpose and followed by a useful bulk-support note. Every sentence earns its place with 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?

The description provides the essential purpose and a notable bulk capability, but with no output schema it does not explain return values, batch size limits, or error behavior. The query parameter is also undocumented, making the description adequate but 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?

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only clarifies that ids supports batched execution and implicitly that id identifies a timesheet entry. The query object parameter is entirely unexplained, leaving a significant 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 says 'Detalha um lançamento de timesheet' (details a timesheet entry), using a specific verb plus resource. This clearly distinguishes it from sibling easyjur_list_timesheet by focusing on detail retrieval rather than listing.

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 only usage guidance is 'Bulk support: accepts ids for batched execution', which clarifies when the ids parameter may be useful. However, the description does not explicitly state when to prefer this tool over alternatives like easyjur_list_timesheet or other get_* 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 communicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the read-only behavior is covered. The description adds useful bulk execution context but does not explain response shape, authentication needs, or error behavior. 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 compact and front-loaded: one clear purpose sentence and one short bulk-support note. Every phrase adds information without unnecessary verbosity.

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 is adequate for a simple read-by-ID operation and the annotations cover the safety profile, but no output schema exists and the return value is not explicitly described. The mysterious query parameter and the exact bulk execution contract are also left unexplained, so completeness is limited.

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 needed to compensate. It only restates token_id and token_ids in broad terms and completely ignores the query object parameter. It also leaves the interplay between required token_id and optional token_ids unclear, so parameter meaning remains under-explained.

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

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

The description clearly states the tool's verb and resource: "Consulta um token de API por ID." This differentiates it from sibling tools like easyjur_list_tokens by specifying retrieval by a token ID, and also mentions bulk support via token_ids.

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 when a specific token is needed and supports bulk token_ids, but it does not explicitly say when to prefer this over alternatives such as easyjur_list_tokens. No exclusions or contrast with sibling tools 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond annotations by disclosing bulk support for user_ids, though it does not describe return format or edge-case behavior.

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

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

Two short, front-loaded sentences with no filler. The core purpose comes first, followed by a compact, useful bulk-support note.

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 lookup with strong annotations, the description covers purpose and bulk behavior. However, the undocumented 'query' object and lack of any return-value or error information leave noticeable gaps, especially since there is no output schema to compensate.

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 description explains user_id ('por ID') and user_ids ('bulk support'), but the schema has 0% description coverage and the 'query' parameter is completely undocumented in both the schema and the description. This leaves a meaningful gap for one 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 uses a specific verb 'Busca' (searches/fetches), a clear resource ('usuário'), and the key lookup criterion ('por ID'). This clearly distinguishes it from sibling tools like easyjur_list_users and other get_* 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 clearly conveys that this is for retrieving a user by ID and additionally notes bulk support via user_ids. It does not explicitly mention list_users as the alternative for listing users or state when not to use this tool, but the intended context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds no additional behavioral context beyond that (e.g., pagination, authentication needs, or return format). Since annotations carry the safety burden, a score of 3 reflects that the description does not enhance transparency further.

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 succinct sentence that leads with the action and resource. There is zero extraneous content, and every word contributes to the core meaning. This is exemplary conciseness, even if under-specification is penalized in other dimensions.

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 parameters including a nested query object, and no output schema. The description does not mention return values, pagination behavior, or how to construct queries. For a moderately complex list tool, more context is expected to enable correct usage, especially without an output schema.

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 0% description coverage, and the description provides no explanation for the parameters page, query, or page_size. It does not clarify what the query object should contain or how pagination works, leaving the agent without essential guidance. The description fails to compensate for the missing schema documentation.

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

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

The description clearly states the action (list) and resource (agenda items), and even specifies that agenda items include deadlines, commitments, and tasks. This distinguishes it from sibling tools like easyjur_get_agenda (single item) and easyjur_list_agenda_grupo (likely lists groups). The verb-resource pairing is specific and 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?

No guidance is provided on when to use this tool versus alternatives. With several sibling list tools (e.g., easyjur_list_agenda_grupo, easyjur_get_agenda) and many other list tools, the absence of any contextual advice leaves the agent to infer usage. There is no mention of prerequisites, filtering scenarios, or when not to use it.

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

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

Annotations already disclose read-only, idempotent, and non-destructive behavior, lowering the burden on the description. The description adds value by mentioning bulk support via grupo_ids, but it does not explain behavioral aspects like pagination, error handling, or response format. This adds some context beyond annotations, earning a 3.

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 concise, with the main purpose in the first sentence and a separate sentence for bulk support. It is front-loaded and easy to parse. It does not waste words, but it could be slightly more structured with explicit parameter hints, so it doesn't earn a 5.

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 5 parameters, a nested query object, and no output schema, the description is incomplete. It lacks information on pagination, filtering via query, page_size semantics, and what the response contains. The annotations cover safety but not operational details, so the description falls short.

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 must explain all parameters. It only mentions grupo_ids for batched execution, leaving page, query, page_size, and grupo_id unexplained. The addition for grupo_ids is helpful but insufficient for the full parameter set.

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 'Lista agenda de um grupo' clearly states the action (list), resource (agenda), and scope (group). It is specific and differentiates from siblings by the 'grupo' scope, though it does not explicitly name alternatives. The name itself reinforces the distinction, so it earns a 4 rather than 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?

The description provides no guidance on when to use this tool versus alternatives like easyjur_list_agenda or other group-scoped tools. It only mentions bulk support, which is a parameter feature, not usage context. There is no statement of prerequisites or scenarios, so it scores low.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. However, the description adds no behavioral information beyond that, such as pagination behavior, result limits, or the purpose of the 'query' nested object. It is a bare statement with zero extra 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 extremely short (three words), but this is under-specification, not conciseness. There is no structure, no front-loaded key information, and it fails to convey essential details like pagination or query capabilities. It is not helpfully compact; it is just sparse.

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 endpoint with three parameters (including a nested query object) and no output schema, the description provides zero explanatory context. It does not mention how pagination works, what the query object expects, or what the response contains. This is severely inadequate for an agent to use 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?

The schema has 3 parameters (page, query, page_size) with 0% description coverage, and the tool description says nothing about any of them. The 'query' object is nested and entirely unexplained, leaving the agent without any guidance on how to construct or use the 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 'Lista despesas' states the resource (expenses) and the action (list), making the purpose understandable. However, it does not differentiate from sibling tools like easyjur_list_despesas_grupo or easyjur_get_despesa, and fails to mention any scoping or filtering behavior beyond the bare listing.

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 easyjur_list_despesas_grupo or easyjur_get_despesa. There is no mention of context, prerequisites, or circumstances that would favor this tool, leaving the agent without decision support.

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 bulk execution capability via grupo_ids, which is useful. However, no other behaviors like pagination, ordering, or response details are disclosed, so it adds minimal extra context beyond annotations.

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

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

The description is concise with zero fluff, front-loading the primary purpose. The bulk support note is appended cleanly. However, it is so short that it leaves out critical parameter context, so it sacrifices completeness 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?

Given no output schema and low parameter coverage, the description is incomplete. It does not explain the query object structure, pagination behavior, or what fields are returned. It also lacks guidance on when to use this tool versus easyjur_list_despesas, making it insufficient for an agent to fully understand the tool's 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 must compensate for explaining parameters. It only mentions bulk support for grupo_ids, but gives no explanation for page, query, page_size. The parameter names are somewhat self-explanatory, but the 'query' object is ambiguous and could confuse an agent without further detail.

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 'Lista despesas de um grupo' (Lists expenses of a group), which is a clear verb+resource+scope. It distinguishes from easyjur_list_despesas implicitly via the group qualifier, but does not explicitly differentiate from the sibling tool.

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 on when to use this tool versus alternatives. It mentions bulk support but does not specify when to choose this over easyjur_list_despesas or other list tools. No exclusions or explicit use cases 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?

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond the generic act of listing, such as pagination behavior, response shape, or whether query filtering is supported.

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 zero filler: 'Lista grupos (pastas/áreas).' The parenthetical adds useful clarification without increasing length or reducing clarity.

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 optional parameters, a nested query object, and no output schema, a one-sentence description is insufficient. The annotations mitigate safety concerns, but the agent is still left without guidance on filtering, pagination, or return values.

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 any of the three parameters (page, query, page_size). While 'page' and 'page_size' are somewhat self-explanatory, 'query' is an object with arbitrary properties and is left completely undefined, which the description fails to compensate for.

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 gives a clear verb ('Lista') and resource ('grupos'), with the clarifying parenthetical 'pastas/áreas' helping to identify the domain. It distinguishes from easyjur_get_grupo and other entity-specific list_*_grupo siblings, though it could be more explicit about scope (e.g., all groups vs filtered).

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 when-to-use guidance, no exclusions, and no mention of alternatives such as easyjur_get_grupo or the other list_*_grupo tools. The intended usage is only implied by the verb 'Lista', so the agent receives no direct support for choosing this over siblings.

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 readOnly, idempotent, and non-destructive behavior, so the description does not need to reiterate these. However, it adds no additional context about authentication, rate limits, or side effects, leaving the agent with only 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, concise sentence that conveys the essential purpose without any fluff or redundant phrasing. It is optimally 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?

The description lacks any information about return values, pagination behavior, or how the query parameter works. While no output schema exists, the minimal description still leaves the agent without sufficient context for effective 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?

The schema lists page, query, and page_size with no descriptions, and the description mentions none of them. With zero parameter documentation, the agent has no way to understand what format 'query' expects or how pagination works.

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 ('Lista') and the resource ('oportunidades'), with a parenthetical clarification that it pertains to CRM/pre-sales, which helps distinguish it from other list operations.

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 the many similar list_* tools (e.g., list_oportunidades_grupo). It only states the action without indicating context or alternative selection 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 description does not need to repeat safety. It adds the bulk behavior (accepts grupo_ids), which is useful, but does not disclose pagination behavior, return format, or error handling. Given annotation coverage, 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?

The description is extremely concise—two short sentences that are front-loaded with the core purpose and bulk support note. There is no filler or redundancy, making it highly 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 the complexity (5 params, no output schema, no param descriptions), this description is incomplete. It fails to explain how to use pagination, query filtering, or page_size, which are essential for a list operation. The bulk support is mentioned but other important parameters are ignored, making the description inadequate for a complete understanding.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains grupo_ids for batched execution, leaving page, query, and page_size undocumented. This is insufficient for a 5-parameter tool; the description adds minimal value beyond the schema for most 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 'Lista oportunidades de um grupo' clearly states the action (list) and the resource (oportunidades) with a specific scope (de um grupo), distinguishing it from the sibling 'easyjur_list_oportunidades' which likely lists all opportunities. The bulk support mention further clarifies an advanced capability.

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

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

The description implies usage for group-specific opportunity listing but does not explicitly state when to prefer this tool over alternatives like 'easyjur_list_oportunidades' or 'easyjur_list_oportunidades' (which lists all). The bulk support hint provides some context but no exclusions or explicit conditional guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the domain types (clientes, contrários, terceiros), but it does not disclose pagination behavior, default page size, or whether the query object supports arbitrary filters.

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

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

The description is a single concise sentence with no filler or repetition. It front-loads the core action and resource immediately, though it is perhaps too concise to compensate for the schema's lack of parameter descriptions.

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 six parameters, a nested query object, no output schema, and no parameter descriptions, the description is not complete enough. It explains what the tool returns semantically but leaves pagination, filter behavior, and the flexible query object 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 provides no meaning for any of the six parameters. While names like cpf and cnpj are somewhat self-explanatory, the query object, page, page_size, and nome parameters receive no explanatory value beyond the raw schema.

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

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

The description uses a specific verb and resource: "Lista pessoas" (lists people), and clarifies the scope with parenthetical categories: clients, opposing parties, and third parties. However, it does not explicitly distinguish this tool from the sibling easyjur_list_pessoas_grupo, so it falls short of full 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?

There is no guidance about when to use this tool versus alternatives such as easyjur_get_pessoa or easyjur_list_pessoas_grupo. The description states what it does but provides no selection criteria, exclusions, or comparative 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, so the agent knows this is a safe read operation. The description adds the bulk execution behavior via 'grupo_ids', which is useful extra context. However, it does not disclose other behavioral aspects like pagination defaults or response format, which is acceptable given 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 extremely concise, consisting of two sentences. It front-loads the core purpose and adds one key behavioral trait (bulk support). Every word earns its place with zero 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 simple list tool with no output schema, the description is adequate but not exhaustive. It covers the primary purpose and bulk capability, but does not mention pagination, filtering, or any prerequisites. Given the annotations and sibling tools, this is minimally complete but lacks depth for agents unfamiliar with the pattern.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meanings. It only explains 'grupo_ids' for bulk support, but leaves 'page', 'page_size', 'query', and 'grupo_id' unexplained. For a list tool, these are likely pagination and filtering params, but the description does not add this clarity, providing limited semantic value.

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

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

The description clearly states the tool's purpose: 'Lista pessoas de um grupo' (list people of a group). The verb+resource is specific and distinguishes it from siblings like 'easyjur_list_pessoas' (which lists all people) and 'easyjur_list_grupos'. The mention of bulk support further clarifies functionality.

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

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

The description implies usage for listing people within a group, but does not explicitly state when to use it instead of other list tools (e.g., easyjur_list_pessoas). No exclusions or alternative tool references are provided, so usage guidance is only implicit through the name and 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, so the safety profile is covered. The description adds value by listing available filters and the catch-all 'query' parameter, but it does not disclose pagination, response format, or default behavior. No contradictions with annotations.

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

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

The description is compact and front-loaded with the main purpose, followed by a concise list of filters. It contains no redundant or filler content, making every sentence earn 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?

Given the tool's 15 parameters, nested query object, and lack of output schema, the description covers the main filters but omits pagination, parameter combination rules, and result behavior. It is adequate for a list tool but not fully detailed for more complex 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?

The input schema has 0% description coverage, so the description compensates by explicitly listing 12 of 15 parameters as useful filters and introducing the 'query' object for additional filters. Pagination parameters (page, page_size) are not mentioned, and formats are unspecified, but the description adds significant semantic meaning.

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

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

Description clearly states 'Lista/busca processos' (verb+resource) and enumerates a list of useful filters, reinforcing its role as a search/list tool. This distinguishes it from single-process tools like easyjur_get_processo, 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 implies usage for listing/searching processos with the provided filters, but gives no explicit when-to-use or when-not-to-use guidance. The 'Demais filtros via query' line offers some direction, but no exclusions or comparisons to sibling list tools 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the bulk behavioral trait ('accepts grupo_ids for batched execution'), which is useful context beyond the annotations. However, it omits other behavioral details such as pagination behavior, return type, or any side effects, though read-only nature is established.

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

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

The description is extremely concise: two short sentences with no filler. It front-loads the core purpose and adds a single relevant note on bulk support. Every word earns its place, and the structure is easily scannable.

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 having a nested query parameter, 5 parameters, and no output schema, the description is minimal. It does not explain the query object, pagination semantics, or what the response contains. While annotations cover safety, the tool's usage complexity demands more context for correct invocation. The description is incomplete for an agent to operate effectively without external 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%, so the description must compensate for parameter meaning. It only addresses grupo_ids (bulk support) and implicitly grupo_id from the tool name, but does not explain query (a nested object), page, or page_size. Given the blank schema, the description fails to provide adequate semantics for most parameters, leaving the agent to guess their format and usage.

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

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

The description clearly states the tool's purpose: 'Lista processos de um grupo' (lists processes of a group). This is a specific verb+resource combination that distinguishes it from sibling tools like easyjur_list_processos (which lacks the group filter) and other entity-specific group 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 description does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The only extra hint is the bulk support note, but it does not explain the distinction between singular (grupo_id) and plural (grupo_ids) usage. With many similar sibling list tools, clearer usage guidance 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral context, such as pagination or filtering behavior, 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 a single short phrase. While it contains no fluff, it is under-specified: it lacks any structural detail or context about the tool's functionality, making it more of a title than a description.

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 3 parameters, no output schema, and no parameter descriptions. The description only states 'List receipts' without covering parameters, return behavior, or use cases. This is inadequate for an agent to confidently 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% (none of the three parameters page, query, page_size are documented in the schema). The description offers no parameter explanations, so the agent has no idea what these parameters mean or how to use them. The description fails to compensate for the missing schema descriptions.

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 'Lista receitas' clearly identifies the action (list) and resource (receipts). It distinguishes from siblings like easyjur_list_receitas_grupo (list receipts group) and easyjur_get_receita (get a single receipt) by focusing on the plural list 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?

No usage guidelines are provided. The description does not specify when to use this tool versus alternatives, nor does it mention any preconditions or exclusions. The agent must infer from the name 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, covering the safety profile. The description adds useful bulk-execution behavior, but it does not disclose pagination, querying behavior, or response characteristics beyond what annotations already 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 extremely concise: two sentences, no filler, and the most important bulk behavior is front-loaded. Every sentence adds value.

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

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

The core purpose and bulk support are clear, and the annotations cover safety semantics, so this is adequate for a simple list operation. However, the tool has 5 parameters including a nested query object and no output schema, and the description does not clarify pagination, filtering, or what exactly is returned.

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 carries the burden for parameter meaning. It explains only the bulk role of grupo_ids but leaves grupo_id vs grupo_ids, query, page, and page_size semantically unexplained.

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 'Lista' with a clear resource ('receitas') and scope ('de um grupo'), distinguishing it from sibling tools like easyjur_list_receitas and easyjur_get_receita. The additional bulk-support note further clarifies the tool's batch capability.

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

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

The description clearly implies group-scoped usage and mentions bulk support via grupo_ids, but it does not explicitly state when to prefer this tool over easyjur_list_receitas or other list variants. No exclusions or alternative recommendations 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 annotations indicate read-only and idempotent behavior, and the description does not contradict this. However, the description adds no additional behavioral transparency beyond the annotations, such as side effects or permissions.

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

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

The description is a single, concise sentence that is front-loaded with the action. It contains no unnecessary words and is easy to parse.

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 schema exists but lacks descriptions, the tool description does not compensate by explaining usage, output, or parameter details. It is too minimal to be considered complete for a developer unfamiliar with the system.

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 parameters (page, query, page_size) are not described in the schema or the tool description. There is no explanation of what 'query' entails or how pagination works, leaving the semantics completely unspecified.

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

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

The description clearly states the tool lists timesheet entries, using a verb and resource. It distinguishes from sibling list tools by mentioning 'timesheet' specifically, though it could provide more detail about the 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 provided on when to use this tool versus other list tools. It lacks context on appropriate scenarios, such as when to list timesheets vs. other resources.

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 only the company scope ('da empresa'), while the safety profile is already covered by annotations (readOnlyHint=true, destructiveHint=false, idempotentHint=true). It does not disclose pagination behavior, result shape, or any auth implications, but this is acceptable for a simple read-only list.

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 clear, front-loaded sentence with no wasted words. It is appropriately short for a straightforward list operation, though it could have included parameter context 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?

For a tool with three parameters, no output schema, and no parameter descriptions, a one-sentence description is incomplete. It lacks pagination/filter semantics and return-value expectations, which are necessary for correct invocation.

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

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

The description provides no information about the three parameters (page, query, page_size) and schema description coverage is 0%. Since the description does not compensate for the missing parameter documentation, agents have no guidance on how to pass filters or pagination.

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 ('Lista') on a specific resource ('os tokens de API da empresa'), clearly identifying what the tool does. The plural 'tokens' distinguishes it from the sibling easyjur_get_token, which retrieves a single token.

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 usage guidance is provided. It does not mention when to choose this list tool over easyjur_get_token, nor does it explain when pagination/filtering parameters 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?

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the basic behavioral safety profile is covered. The description adds only the word 'disponíveis' and does not explain pagination, filtering, or return behavior, but there is 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 short phrase with no filler, and the main verb is front-loaded. It is concise, though the brevity contributes to under-specification rather than being information-dense.

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 optional query parameter is completely unexplained, so the agent cannot predict the returned data or how to narrow the result. The annotations cover safety, but the tool description is too sparse for confident invocation beyond the basic purpose.

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

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

The only parameter is an optional nested 'query' object, and the schema-description coverage is 0%. The description says nothing about what the query object means, what keys are allowed, or how it affects the list of tribunais, leaving the agent completely without semantic guidance for the parameter.

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

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

The description uses a specific verb ('Lista') and a clear resource ('tribunais/órgãos disponíveis'), so the agent can understand this is a court/org listing tool. It is distinct from sibling list tools by resource type, though it does not describe any additional scope or filtering behavior beyond 'disponíveis'.

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, nor any mention of prerequisites or exclusions. The intended usage is only implied by the resource name and sibling context, which is weak guidance for an agent choosing among many list_* 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-read nature is covered. However, the description adds no extra behavioral context beyond annotations, such as pagination behavior, default ordering, or authentication requirements. With only the description, an agent would not know if the tool returns all users by default or how the query parameter affects results.

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 no fluff, making it concise. However, it is under-specified; it lacks any additional structure or context that would help with invocation, such as parameter usage or response details. This is borderline under-specification rather than effective 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?

The tool has a relatively simple purpose but includes three parameters, one being a nested object, and no output schema. The one-line description is inadequate to fully understand behavior, especially the 'query' parameter and pagination semantics. Given the presence of many sibling list tools, more context would be needed to choose and use this 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?

The input schema has zero description coverage for all three parameters ('page', 'query', 'page_size'), and the description does not compensate. It provides no explanation of what 'query' should contain, the structure of the nested object, or how pagination works. An agent cannot infer the expected input formats from the given information.

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

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

The description clearly states the tool's function with a specific verb ('Lista') and resource ('usuários do escritório'), and it distinguishes itself from sibling tools like 'easyjur_get_user' and other list tools for different entities.

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, or on any exclusions or conditions. The one-line description offers no context about pagination, filtering, or typical use cases.

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, which convey a safe read-only operation. The description adds only the note about accepting processo_ids for bulk execution, which is already implied by the schema definition. It does not disclose any additional behavior such as return format, pagination limits, or error handling, offering minimal value 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 very short and free of filler, which is a positive aspect. However, it is under-specified, sacrificing essential information for brevity. It does not front-load a clear action or provide structured context, so while not verbose, it does not meet the 'every sentence earns its place' ideal because the sentences do not convey needed 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 the tool has 3 parameters with no schema descriptions, no output schema, and the description provides nearly no explanation of the tool's behavior or parameter semantics, it is severely incomplete. An agent would have to guess what 'query' does, what returns, and how to effectively use the tool. This is far below the minimum viable description for such a 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%, so the description must compensate for parameter explanations. It only mentions that processo_ids enables batched execution, but fails to explain processo_id (the required parameter) and the query object. This leaves the meaning and usage of most parameters undocumented, which is insufficient for an agent to construct correct calls.

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 'Documentos de um processo' translates to 'Documents of a process' but lacks an explicit verb like 'get', 'list', or 'fetch'. While it indicates the resource (documents associated with a process), it does not clearly state what action the tool performs. The bulk support note adds operational detail but not fundamental purpose. It is not a tautology, but it is vague and fails to distinguish from similar process-related 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. It mentions bulk support (accepts processo_ids) but does not explain when batching is appropriate, what the fallback is, or under what conditions this tool should be invoked. There is no mention of alternative tools 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 provide the core safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false). The description adds useful context about the batch execution capability (processo_ids), which goes beyond annotations. However, it does not describe return format, pagination behavior, or whether the query parameter supports additional filtering, so transparency remains partial.

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 concise: two short, front-loaded sentences. The first states the core purpose, the second adds the bulk capability. There is no filler or excess wording.

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, low parameter documentation, and a non-trivial query object, the description is too sparse to be fully actionable. It does not say what fields/objects the financial entries contain, what filters are supported, or how the query parameter interacts with processo_id. An agent could invoke the tool with unscaled information in more complex scenarios.

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

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

Schema description coverage is 0%, so the description must explain all three parameters. It does explain that 'process_id' identifies the process and that processo_ids are for batch execution, but the 'query' object parameter is entirely undocumented, including its allowed keys and semantics. Since one parameter is a nested object with no field-level schema detail, the description insufficiently compensates.

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 resource as 'Lançamentos financeiros de um processo' (financial transactions of a process), which clearly suggests a retrieve/list operation for financial entries belonging to a case. However, it lacks an explicit action verb such as 'list', 'get', or 'retrieve', and it does not differentiate itself among the many sibling process sub-resources like easyjur_processo_documentos or easyjur_list_despesas/list_receitas.

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 only usage hint is 'Bulk support: accepts processo_ids for batched execution,' which tells the agent when to use the multi-process parameter but not when to choose this tool over alternatives. There is no guidance about when not to use this tool, no mention of required filter context, and no differentiation from list_despesas, list_receitas, or other process-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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating this is a safe read operation. The description adds the bulk support note ('aceita processo_ids para batched execution'), which is useful beyond annotations. However, it does not describe the return format, pagination, or any other behavioral details, but given the annotations, 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?

The description is very short (one line plus a note), which is efficient. Every sentence provides some value: the purpose and the bulk support caveat. It is not verbose, but could be improved by elaborating on usage in a structured way without losing 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?

The tool is relatively simple (3 params, no output schema), but the 'query' parameter is completely unexplained, which is a critical gap for an agent to use it correctly. The bulk support note is helpful but does not compensate for the lack of guidance on the 'query' object. Given the sibling tools, more context on how this fits with other processo sub-resources would improve completeness.

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 a 'query' property with additionalProperties (free-form object) that the description does not explain at all—this is a significant gap since 0% schema description coverage means the agent has no idea how to use 'query' or what it filters. The description mentions bulk support but does not explain the relationship between 'processo_id' and 'processo_ids' (e.g., whether processo_ids overrides processo_id). No parameter details beyond the schema.

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

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

The description 'Mensagens/andamentos de um processo' clearly states that this tool retrieves messages/progress events of a legal process, using the Portuguese term 'andamentos' which means 'developments' or 'progress'. The verb is implied ('get'/'list') and it distinguishes from siblings like easyjur_processo_documentos (documents) and easyjur_processo_partes (parties), but does not explicitly state that it is a retrieval operation, relying on the readOnly hint.

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

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

The description does not specify when to use this tool versus others such as easyjur_processo_documentos or easyjur_processo_partes. It only mentions bulk support for multiple processos, but gives no context on typical use cases or exclusions. No guidance is provided on how to 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds one new behavioral trait: accepting processo_ids for batched execution. However, it does not describe pagination, return shape, breadth of results, or how the optional query object affects 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 very short, front-loads the main concept, and contains no filler or redundant elaboration. Both sentences serve a purpose: one names the resource and one identifies batch support.

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 no explanation of the response format, so the description should compensate by stating what the tool returns and in what circumstances. It does not explain the query parameter, nor clarify singular vs plural input usage, leaving agents with significant ambiguity for a moderately parameterized 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 coverage is 0%, so the description carries responsibility for clarifying parameters. The bulk-support senten provides insight into the purpose of processo_ids, but the query parameter is entirely unexplained and the relationship between the required singular processo_id and plural processo_ids is not specified.

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 'Partes de um processo.' identifies the resource (parties of a legal case) but does not state an explicit verb or operation such as get/list/retrieve. It roughly distinguishes from sibling processo_* tools by resource name, but the purpose statement remains a noun phrase rather than a complete tool definition.

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 instead of alternatives. The bulk-support note is a execution hint, but it does not explain when processo_ids should be preferred or when the query parameter should be used. No alternative tools or exclusion cases are offered.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context by mentioning bulk execution through processo_ids, but it does not describe response shape, pagination, batch limits, or error 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 two short sentences with no filler and front-loads the core resource meaning. It could be slightly more informative, but it is appropriately concise.

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

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

For a tool with three parameters, a nested query object, and no output schema, this description is too thin. It explains neither what 'pedidos' entails nor how query filtering works, leaving important invocation details ambiguous.

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 explains the processo_ids bulk behavior. The required processo_id parameter and the query object are left undocumented, and the relationship between processo_id and processo_ids is unclear.

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 the resource ('Pedidos de um processo') and adds bulk support, making clear that this tool retrieves requests associated with a legal process. It distinguishes this from sibling subresource tools (documentos, financeiros, partes), though it lacks an explicit verb such as 'get' or '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, such as easyjur_get_processo or easyjur_list_processos. The bulk-support note implies batched use but does not explain selection criteria or exclusions, so the agent must infer usage context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description does not need to restate those. The description meaningfully adds the batch-execution behavior via processo_ids, which goes beyond the structured annotations and reveals a useful capability. No contradiction exists.

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 states the main purpose and then adds the bulk support note in one extra line. There is no wasted prose, though the brevity comes at the cost of the detail needed for larger lot settings.

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 empty schema descriptions, nested query object, and no output schema, the tool is under-specified. The description does not explain return format, how the query object is used, or how process_id and process_ids interact, which is insufficient for reliable autonomous invocation.

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

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

Schema description coverage is 0%, so the description has to explain the parameters. It only mentions processo_ids for bulk execution, leaving the query object and the relationship between processo_ids and the required processo_id unclear. The agent may struggle to construct valid calls, particularly for the nested query 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 identifies 'Processos vinculados a um processo', which clearly refers to retrieving processes linked to a given process, differentiating it from sibling tools like easyjur_processo_documentos or easyjur_processo_partes. However, it lacks an explicit verb such as 'get' or 'list', so it stops slightly short of maximum clarity.

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 bulk support note implies this tool is good for retrieving linked processes for one or multiple process IDs, but it does not explicitly explain when to prefer it over alternatives such as search/list options. It conveys usage context but provides no exclusions or alternative comparisons.

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 goes beyond the minimal annotations, disclosing key behavioral traits: invoke works even when the MCP is not installed, runs one-off without bloating the toolkit, returns connect links for auth and checkout links for payments, and notes that writes require workspace owner/admin. This provides critical operational context the annotations do not convey.

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

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

The description is long but well-structured and front-loaded with the primary purpose. Every sentence adds value: core flow, invoke specifics, install distinction, list_tools, billing, and prompt library. It could be more concise by trimming some redundancy (e.g., repeated mention of 'pontualmente'), but the density is justified given the tool's complexity.

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

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

Given the tool's complexity (multi-action, 23 params, no output schema), the description is remarkably complete. It covers all major action categories, special invoke behavior, auth/billing flows, permission requirements, and the prompt library. It effectively orients the agent to handle search, describe, install, invoke, subscriptions, and prompt operations without needing external 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?

With 23 parameters and 0% schema description coverage, the description must compensate. It explains the core action parameter (action enum), and clarifies how mcp_id, tool_id, arguments, and prompt-related parameters fit into the workflows. While it does not explicitly detail every parameter (e.g., conversation, prompt_vars, tier_slug), it gives enough context for an agent to infer usage, earning a 4 above baseline.

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

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

The description clearly states the tool's purpose as the official MCP marketplace and catalog, with a specific verb (marketplace, catalog, run) and resource. It distinguishes itself from sibling easyjur tools by focusing on MCP discovery, management, and invocation, and even differentiates between core MCP actions and the prompt library.

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

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

The description provides explicit usage guidance, laying out the core flow (search → describe → invoke) and explaining when to use invoke vs install (prefer invoke for one-off, install for permanent). It also clarifies when to use list_tools, subscribe/cancel, report_bug, and request_mcp, and separates the prompt library usage. This is exemplary when-to-use guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, which covers safety. The description adds the requirement to include a conversation array for reproduction, which is a useful operational detail, but it doesn't describe side effects or return behavior. Given annotations cover the risk 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?

The description is a single sentence that is direct and front-loaded with the purpose. It conveys the essential information without filler. Every word earns its place.

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

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

For a simple feedback tool with no output schema, the description covers the core purpose and one critical parameter (conversation). Annotations provide safety info. It lacks explanation of the context parameter or expected message content, but overall it's reasonably complete for the tool's simplicity.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains the 'conversation' parameter ('Include the conversation array with recent messages for reproduction'). The required 'message' and optional 'context' parameters are not explained. This is partial but insufficient for full compensation.

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

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

The description clearly states the purpose: 'Report a bug, missing feature, or send feedback.' It uses a specific verb ('report') and resource ('bug'), and distinguishes itself from sibling tools that are all business-specific easyjur_* operations. The scope is 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?

It gives a clear usage context (reporting bugs/features/feedback) but doesn't explicitly exclude alternatives. Since siblings are all domain operations, the purpose alone effectively differentiates it, and the instruction to include conversation for reproduction provides actionable guidance. Missing explicit 'when not to use' slightly lowers the score.

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 the specific behavioral detail that both the platform and adapter versions are returned, which is useful context beyond the annotations. It does not describe output format, but for a simple info tool this is acceptable.

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

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

One concise sentence that front-loads the action and target, with no wasted words. It clearly states exactly what the tool does without redundant elaboration.

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

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

For a zero-parameter, read-only version query, the description plus annotations fully cover purpose, safety, and behavior. No output schema exists, but the simple return (platform and adapter versions) does not demand detailed explanation. Sibling tools do not require exclusion guidance here.

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 there is no parameter semantics burden on the description. The schema coverage is trivially 100% with no properties, and the description correctly indicates no inputs are needed. Baseline 4 applies per rubric for zero-parameter tools.

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

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

Description provides a specific verb ('show') and clear resource ('current MCP platform and adapter versions'), which fully states what the tool does. It differentiates from siblings like easyjur_api_status or toolkit_info by focusing specifically on version information.

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

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

The description implies when to use the tool—when you need to know platform/adapter versions—but it does not explicitly state use cases or compare with alternatives. Given the diagnostic nature of the tool, implied usage is adequate but not explicit guidance.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety and repeatability. The description adds value by detailing exactly what data is returned (installed MCPs, connection status, accounts, catalog tool counts), which is relevant behavioral context beyond the annotations. No contradictions exist.

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, well-structured sentence that delivers all essential information without repetition or filler. It is front-loaded with the verb and resource, followed by a natural list of output details. Maximum efficiency.

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, the description must convey what the tool returns, and it does so comprehensively: installed MCPs, connection status, accounts, and catalog tool counts. Combined with rich annotations covering safety, this is fully adequate for an informational utility tool.

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

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

The tool has zero parameters, so the description's job is minimal. The schema coverage is 100% (vacuously), and the description doesn't need to explain parameters. A baseline of 4 is appropriate for no-parameter tools.

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

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

The description clearly specifies the verb (returns) and the resource (toolkit state) and enumerates exactly what information is included: installed MCPs, connection status, accounts, and catalog tool counts. This distinguishes it from all sibling tools, which focus on specific operations or data retrieval.

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?

While no explicit 'use this when' guidance is given, the description makes it obvious that this is a diagnostic/status tool. Given the sibling list includes many action-oriented tools, the purpose is clearly distinct, and there are no competing alternatives for this functionality. A short 'use to inspect connectivity before other calls' would have earned a 5.

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