Legal MCP (alternativa ao Jusbrasil)

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

The description adds useful behavior beyond the annotations: config header yields a permanent connection, while passing a token yields a session-only login, and no args returns a link. It does not fully spell out side effects or success/failure return values, but annotations already cover idempotency and non-destructiveness.

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

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

The description is dense and front-loaded, with no fluff, but the long single sentence with parenthetical clauses and multiple alternatives could be structured into clearer separate instructions. Still, every part adds necessary information.

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

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

For a one-parameter auth tool with no output schema, it covers the no-arg return (the link), the token-paste path, and the persistent-config alternative. It doesn't state the response on a token success/failure, but the invocation guidance is sufficient for an agent to call it correctly.

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

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

With 0% schema coverage, the description carries the full burden for the optional `token` parameter. It explains that token is a JWT/access token pasted by the user and how to pass it, compensating well for the bare schema.

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

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

The description clearly identifies the tool as MCP.AI authentication for IDE agents, with a concrete browser-login + access-token flow and two invocation paths (no args for a link, token for login). This specific verb+resource is unambiguous and easily distinguished from the unrelated calculo_* sibling tools.

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

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

It explicitly differentiates the persistent config-header approach ('best... permanent, non-expiring') from the session-only paste/login path, and states exactly when to call with no args versus with { token }. This gives the agent clear selection criteria for both setup and invocation.

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, destructiveHint=false. Description adds value by listing return fields and noting it's free, but does not add behavioral details beyond annotations. No contradiction.

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?

Description is a single sentence with a useful fragment. Front-loaded with verb and resource, no wasted words. Could be slightly more structured, but effective.

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

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

For a simple tool with 1 param and no output schema, description lists return fields and provides usage context. Lacks parameter format guidance, but overall complete for basic 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?

Schema description coverage is 0%, but description does not clarify expected format of 'cnpj' (e.g., masked vs raw digits, required length). Parameter name alone is insufficient for agents to invoke correctly without assumptions.

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 verb ('consulta') and specific resource ('cadastral de um CNPJ'), listing key data fields (razão social, sócios, etc.) and distinguishes from sibling 'cnpj_processos' by mentioning its utility before searching lawsuits.

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

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

Description implies usage context: 'Útil pra identificar a empresa e seus sócios antes de buscar processos' indicates when to use this tool relative to the sibling. No explicit when-not-to-use, but 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 indicate read-only, idempotent, non-destructive behavior. Description adds valuable context: it's free, resolves CNPJ to legal name and partners, searches DJEN, and provides complete process numbers. 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?

Description is concise (one paragraph, three sentences) with no wasted words. Front-loaded with the key function ('DESCOBERTA por CNPJ'). 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?

Comprehensive for a simple tool with two parameters and no output schema. Covers input, optional behavior, output elements (complete process numbers), and next steps (enrichment with datajud). Minor gap: no error handling or format specifications for CNPJ.

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 has 0% parameter descriptions. The description explains both parameters: 'cnpj' is implied in 'resolve o CNPJ' and 'incluir_socios' is clarified as optional inclusion of partner processes. Adds meaning 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 clearly states the tool resolves a CNPJ into a legal name and partners, searches for processes by name in DJEN, provides complete process numbers, and optionally includes partner processes. It distinguishes from siblings like 'cnpj_consultar' by specifying the process search aspect.

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?

Provides explicit context on when to use (resolving CNPJ and searching processes) and optional behavior (include socios). Offers post-usage guidance to enrich with datajud tools. Does not explicitly exclude alternative tools but implies appropriate use.

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

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

Annotations already establish this is read-only, idempotent, and non-destructive. The description adds useful behavioral detail beyond that by specifying the two main response states: authenticated:true with empty pending[] when all providers are connected, and connect_url plus per-install URLs when credentials are missing. This helps an agent predict what to expect.

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, front-loads the core purpose, and then adds only the essential conditional details. Every sentence contributes meaningful information, and there is no waste.

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 is complete enough. It tells the agent what information will be returned, what the success condition looks like, and what happens when credentials are missing. The low complexity means no additional guidance is required.

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 does not need to explain any input semantics. The baseline of 4 applies because there is no parameter burden at all.

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

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

The description clearly states the tool's purpose: returning connection status and URLs. It distinguishes connect from its sibling authenticate by framing it as a status/read operation rather than an action, and the conditional output descriptions reinforce this.

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

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

The description makes clear that this is the tool to call when checking connection state or getting URLs. It does not explicitly mention alternatives like authenticate, but the context strongly implies connect is for status checking rather than initiating authentication, so usage is clear without being fully explicit.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, non-destructive), the description discloses the paid-broker dependency and the fallback behavior when `nome` is omitted. This adds meaningful context about external prerequisites and failure modes. No contradiction with annotations is present.

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, immediately announcing the tool's purpose. Every sentence adds essential information: what the tool does, why `nome` is needed, and what happens when it is missing. No filler or redundant content.

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

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

For a 2-parameter read-only search tool, the description covers core behavior, parameter dependency, and fallback output. It does not describe the success output format or return fields, and there is no output schema to compensate, so a small completeness gap remains.

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

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

With 0% schema description coverage, the description compensates partly by explaining that `nome` is recommended and required for resolution without a paid broker. However, the `cpf` parameter itself lacks format guidance (e.g., digits only, masking) and the exact role of `cpf` in the lookup remains under-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 states a specific action ('busca os processos') with a clear resource (processos da pessoa) and scope (Diário/DJEN), and clarifies that discovery works via person name rather than public CPF-to-name mapping. This clearly differentiates it from the sibling tool cpf_validar, which is about CPF validation.

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

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

The description gives explicit usage guidance: inform the `nome` parameter because CPF-to-name is not public data; without `nome`, the tool only works if a paid broker is configured, otherwise it returns an instruction requesting the name. It does not explicitly name alternative tools or exclusion cases, so it stops short of a 5.

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

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

Annotations already indicate readOnly, idempotent, and non-destructive behavior. Beyond that, the description adds important behavioral context: it validates only check digits, does not reveal the holder's identity, and also reports identity broker availability. This is useful context beyond the annotations, though it does not detail output 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?

The description is exactly two sentences, front-loads the main purpose, and includes only relevant information. Every part is meaningful: what is validated, how, the availability check, and the privacy guarantee. No wasted words.

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

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

For a single-parameter read-only validation tool with strong annotations, the description provides enough context to select and invoke the tool. It explains the core function, the privacy constraint, and the added availability check. It could briefly mention the return value, but the simplicity of the tool reduces the need for more detail.

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 provides only the parameter name 'cpf' and type 'string', with no description. The tool description adds the meaning that this CPF string is used for validating check digits via mod 11, but it does not specify accepted formats (e.g., with/without punctuation, length) or what happens with invalid input. This is a moderate improvement over the bare schema.

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

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

The description uses a specific verb ('Valida') and names the exact resource (CPF), plus the method (dígitos verificadores mod 11). It also states the secondary purpose (identity broker availability), which clearly distinguishes the tool from siblings like authenticate and cpf_processos.

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

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

The description implies this tool should be used when someone needs to validate CPF check digits, but it does not explicitly state when to prefer it over sibling tools or when not to use it. There is no mention of alternatives or exclusions, so usage guidance remains only implicit.

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

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

Annotations already mark the operation as read-only and idempotent. The description adds useful behavioral context beyond the annotations: the tool returns a URL to a PDF, not the PDF itself, and the input hash comes from the search response. No contradiction with annotations.

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

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

A single, well-structured sentence that is front-loaded with the main purpose and includes the necessary parameter relationship. No filler or redundant content.

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

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

For a simple one-parameter lookup tool with strong annotations, the description is complete enough: it states what is returned, the required input, and where the input comes from. No output schema is needed to understand the basic behavior.

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

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

Schema description coverage is 0%, but the description compensates by explaining that 'hash' is the field 'retornado na busca'. This gives the parameter practical meaning and provenance, even though it does not describe the hash format or length.

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: 'Retorna a URL da certidão (PDF) de uma comunicação do DJEN' and specifies the input dimension ('pelo seu hash'). It also distinguishes itself from the sibling search tool by retrieving a certificate URL for an already-known hash.

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 explains the intended workflow: use the hash returned in the search results from the DJEN search tool. It gives clear context for when to call this tool, though it does not explicitly mention when not to use it or name alternatives.

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

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

As anotações já declaram readOnly, idempotente e não-destrutiva; a descrição soma contexto valioso: cobertura apenas de publicações no Diário a partir de 2020, semântica do count_processos 0, bloco ausencia, e caráter grátis/sem captcha. Não há contradição com as anotações.

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 é densa mas sem desperdício: propósito, escopo, limitação, alternativa e próximo passo em poucas frases. A informação mais importante vem primeiro e cada oração adiciona valor operacional.

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?

Apesar de não haver output schema e o esquema de entrada ter 0% de descrição, a descrição explica o formato do retorno (lista, count_processos, bloco ausencia) e as limitações. Ainda assim, não documenta os parâmetros opcionais de paginação/filtro, o que a impede de ser totalmente completa para um chamada avançada.

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?

Com cobertura do esquema em 0%, a descrição precisa compensar, mas só dá semântica ao parâmetro nome_parte ('busca por NOME de parte'). Os demais parâmetros (pagina, data_inicio, sigla_tribunal, itens_por_pagina) não são explicados nem no esquema nem na descrição. O valor agregado além do esquema é mínimo para a maoria dos parâmetros.

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

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

A descrição abre com verbo específico e recurso ('DESCOBERTA por NOME de parte') e define o retorno (lista de processos agrupados por número, com partes e tribunal). Ela também diferencia a ferramenta de alternativas ao dizer que entrada por CPF/CNPJ ou processos dormentes deve usar as tools processos_*.

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

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

A descrição é explícita sobre quando usar: busca pelo nome, grátis e sem captcha. Ela também dá condição de não-uso: para CPF/CNPJ ou processos dormentes, usar processos_*. Ainda orienta o próximo passo ('enriqueça com datajud') e aler ta sobre falso-negativo com count_processos 0.

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. The description adds substantial value beyond that: coverage starts in 2020 and varies per tribunal, empty results return an `ausencia` block with possible reasons, and each returned item contains the full communication text. 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 dense but well-organized: purpose first, then item content, then important caveats and empty-result behavior. Every sentence contributes meaning, and nothing is repeated or padded.

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

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

For a read-only search tool with no output schema, it is unusually complete: it covers scope, coverage limits, empty-result structure, and how to confirm absence of a process. It falls just short of full completeness because several input parameters remain under-specified and the non-empty result structure is only outlined, not detailed.

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 schema_description_coverage at 0%, the description must compensate for the schema. It explains the main semantic filter dimensions (OAB, lawyer, process number, tribunal, date) but does not clarify parameters like `meio`, `texto`, `pagina`, `nome_parte`, or `itens_por_pagina`. Partially helpful, but with clear gaps.

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 opens with a specific verb and resource ('Busca publicações/intimações no DJEN') and lists concrete filter dimensions: OAB, lawyer name, process number, tribunal, and date. It also explicitly distinguishes this tool from jurisprudence/ementa databases and process registries, clearly separating it from siblings like jurisprudencia_buscar and processos_buscar_por_nome.

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 states when to use the tool (search published DJEN communications by the given criteria), when not to use it (not for jurisprudence, not a process registry), and names an alternative (datajud_get_processo) for historical confirmation when results are empty. This is explicit and actionable routing 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?

Beyond the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false), the description discloses several non-obvious behaviors: null fields mean absence of information in the source, not a defect; zero results don't prove non-existence; and search operators (space, quotes, OR, minus) affect query semantics. This materially helps the agent interpret results and craft better queries.

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 but information-dense, with the core purpose and return fields in the first sentence, followed by logical caveats and usage notes. Every sentence adds value—none repeat the schema or annotations. The flow from purpose to follow-up tool to edge cases to parameters is well organized.

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 required parameter `termo` is thoroughly explained, the return shape is described, and edge cases (null fields, zero results) are covered. However, with no output schema and no property descriptions in the input schema, the lack of guidance on optional filters like date range and `tipo` leaves a moderate gap for an agent aiming to build precise queries. Still, the most essential call-time information is present.

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

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

Schema description coverage is 0%, so the description must compensate. It does a good job for `termo` (full operator syntax) and `tribunais` (scope control), but it leaves `max`, `tipo`, `data_de`, `data_ate`, and `ordenar` unexplained. Since five of seven parameters are only documented by their schema names/types, the compensation is partial and the agent may guess at date formats or allowed `tipo` values.

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 opens with a specific verb and resource: 'Busca jurisprudência (acórdãos, súmulas, orientações jurisprudenciais, temas) por termo ou tese.' It lists the types of content covered and the output fields, making the tool's scope unambiguous. It also implicitly distinguishes itself from the sibling jurisprudencia_documento by noting that full texts are read with that tool, so an agent can tell search from 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 description gives clear guidance on when to use jurisprudencia_documento (when `texto_integral_disponivel: true`) and explains the effect of omitting `tribunais` (broad search). It also warns that zero results may indicate vocabulary mismatch or overly narrow filters. However, it does not explicitly address when to prefer sibling jurisprudencia_sumulas, so it stops short of a full when-to-use/alternatives matrix.

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

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

Annotations already establish that the tool is read-only and idempotent, so the description's extra detail is useful rather than redundant: it explains that a result without id is not readable, that other decisions appear in outras_decisoes_do_processo, and that ids batch execution. No contradiction with the annotations; no harmful side effects are implied.

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 core purpose stated first followed by precise usage rules. Every sentence adds information: input source, fallback behavior, multi-decision behavior, and bulk support; no wasted words.

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

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

For a read-only fetch tool with no output schema, the description covers the main inputs, fallback route, and expected response context (full text plus other decisions). The only real gap is the tribunal parameter, but the core invocation path is fully specified.

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 carry the parameter semantics, and it does for id (from a prior search result), numeracao (CNJ number), and ids (bulk). However, tribunal is never explained, and the relationship between numeracao and the CNJ number is only implicit, leaving part of the schema under-documented.

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 opens with a specific verb-resource pair ('Lê o INTEIRO TEOR de uma decisão') and explicitly contrasts full text with the resumo, distinguishing it from the search-focused sibling jurisprudencia_buscar. The phrase 'não o resumo' removes ambiguity about what this tool does.

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

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

It states exactly when to call the tool: use the id from a jurisprudencia_buscar result with texto_integral_disponivel: true, or use the CNJ number. It also gives an explicit exclusion and fallback ('Resultado sem id não é legível por aqui, abra a url'), plus guidance for processes with multiple decisions.

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. The description adds useful behavioral details beyond that: binding súmulas are included, full text appears in the 'ementa' when available, and cancelled/repealed súmulas are marked in the text. This adds real operational context without contradicting 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?

Two dense sentences with no filler. The main purpose is front-loaded, followed by the sibling relationship and then useful output behavior. Every sentence 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 two-parameter read-only search tool, the description is largely complete: it defines the query input, notes the fixed type, and explains key output behavior (ementa content and cancellation marking). It could elaborate on response format or max semantics, but the shortcut reference to jurisprudencia_buscar compensates for much of that missing detail.

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 much of the burden. It clarifies 'termo' as the search keyword and implies the fixed 'tipo=Súmula', but it does not explain the 'max' parameter. The required parameter is clear, while the optional max remains only inferable from its name and number type.

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 and resource: 'Busca SÚMULAS (incluindo vinculantes) por termo.' It goes further and explicitly distinguishes itself from jurisprudencia_buscar by declaring itself an 'Atalho' with a fixed 'tipo=Súmula', so there is no ambiguity about what it does or how it differs 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?

The description gives clear usage context: it is a shortcut to jurisprudencia_buscar for Súmula-only searches, with 'tipo=Súmula' pre-applied. It does not explicitly state when not to use it or mention alternatives like jurisprudencia_documento, but the shortcut framing makes the intended scope reasonably 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?

While annotations declare readOnlyHint=true, the description states 'Atualiza o estado' (updates state), which contradicts the read-only claim. The description adds bulk support info but fails to resolve this inconsistency, leading to misleading behavioral expectations.

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

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

Two sentences plus a line for bulk support, all front-loaded with key actions. No redundancy; 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?

No output schema, and the description only says 'returns what changed', which is vague. Prerequisites (e.g., existing monitors) are implied but not stated. Overall adequate but not complete for a new user.

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 has 0% description coverage, but the description explains 'watch_id' for specific and 'watch_ids' for batch, adding significant meaning. It does not detail parameter format or constraints, but coverage is adequate.

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 checks for novelties in monitoring immediately, distinguishing from the automatic cycle. It specifies usage for a specific watch_id or all monitors. Among siblings like 'legal_listar_monitoramentos' and 'legal_monitorar', this tool's purpose is distinct.

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 indicates when to use (immediate check) and how to pass parameters (specific or all), but does not explicitly contrast with siblings or provide when-not-to-use scenarios. Usage context is clear but lacks explicit alternatives.

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

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

The description adds value beyond annotations by warning that data may be incomplete/outdated and advising confirmation on official court websites. Annotations already indicate read-only, idempotent behavior, so the description's caveat about data quality provides useful behavioral context.

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

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

The description is concise (3 sentences) and well-structured: purpose first, then accepted inputs, return format, and a warning. Every sentence adds value, and no filler is present.

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

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

The description explains the main input options and return format (list of processes with number, parties, court) and includes a quality warning. However, with 11 parameters and no output schema, it leaves several parameters unexplained and does not detail the output structure beyond a list and warning. Moderate 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 description only explains 5 of 11 parameters (nome, cnpj, cpf, nome_titular, numero_processo), with schema description coverage at 0%. Parameters like max_processos, incluir_socios, sigla_tribunal are left undocumented, requiring the agent to infer from names. This is insufficient given the schema's lack of 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 clearly states the tool provides a legal X-ray of a person or company, discovering lawsuits and optionally progress. It specifies accepted identifiers (name, CPF, CNPJ, or case number) and the return format. However, it does not explicitly differentiate from sibling tools like cpf_processos or processos_buscar_por_documento, which have overlapping 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 instructs to provide only one identifier ('informe APENAS um') but offers no guidance on when to use this tool versus alternatives (e.g., for CPF-specific queries). There is no mention of prerequisites or context-specific use cases, leaving the agent to infer usage.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is known. The description adds no extra behavioral context, such as what 'monitoramentos' entails or any potential side effects, leaving the agent with minimal additional insight.

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 one sentence, but it could be more informative without being verbose. It is front-loaded but lacks substance like explaining what a 'monitoramento' is or the output format.

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 lack of an output schema, the description should explain what the tool returns (e.g., a list of monitoring IDs or names). It fails to do so, leaving the agent uncertain about the output's structure. The context of 'monitoramentos ativos' is minimally explained.

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?

There are no parameters, and schema coverage is 100%. The description does not need to add parameter information, and the baseline score of 4 is appropriate since the schema already handles everything about 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 verb 'Lista' and the resource 'os monitoramentos ativos do workspace', making it clear what the tool does. However, it does not differentiate from sibling tools that list other types of data, like 'processos_buscar_por_nome' or 'djen_search_comunicacoes', but within the context of monitoring it is specific.

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 using 'legal_checar_novidades' to check for updates, or when not to use it. The context is implied by the tool's purpose but not explicitly 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?

Description discloses that the tool creates a monitoring that sends alerts via webhook, adding behavioral context beyond annotations. It does not contradict annotations (readOnlyHint=false, destructiveHint=false). No hidden effects are missing.

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

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

Two sentences, front-loaded with purpose, but dense. Could be slightly more concise, but no redundancy.

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

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

Covers three monitoring types and webhook event, but omits description of several parameters (label, sigla_tribunal, intervalo_horas) and doesn't mention that monitors can be listed/removed. Not fully complete for an 8-parameter 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?

Despite 0% schema coverage, the description explains the monitoring criteria (numero_processo, nome/cnpj, oab+uf) but does not cover all parameters like label, sigla_tribunal, intervalo_horas. Some meaning added, but incomplete.

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

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

Description clearly states it creates a monitoring for new movements, processes, or publications, using specific parameters. It distinguishes itself from sibling tools like legal_checar_novidades (check immediately) and legal_listar_monitoramentos (list monitors).

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?

Explicitly says when to use this tool (to set up monitoring) and when to use legal_checar_novidades (to check immediately). Also describes how alerts are delivered (via webhook event). Provides clear context for usage.

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

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

Annotations already indicate non-destructive and non-read-only behavior. The description adds that bulk support is available, but does not elaborate on side effects, permissions, or reversibility.

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

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

Two sentences, no unnecessary words. The action and key parameters are front-loaded, making it efficient for an AI agent 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?

For a simple removal tool, the description covers the basic functionality. However, it lacks information about return values or error handling, which is not required but would improve completeness. The existing annotations and sibling context partially 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?

Schema description coverage is 0%, but the description explains 'watch_id' as the monitoring ID and mentions bulk support via 'watch_ids'. This adds meaning beyond the raw schema, but lacks detailed descriptions for each parameter.

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

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

The description clearly states the action of removing/deactivating a monitoring by its ID, and the name reinforces this. It distinguishes from siblings like 'legal_listar_monitoramentos' and 'legal_monitorar', which are listing and creating, respectively.

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 explicit guidance on when to use this tool versus alternatives. No mention of prerequisites or context for when to choose it over other monitoring 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?

Beyond the annotations, the description discloses important behaviors: invoke runs an MCP even when it is not installed, does a one-off run without adding the MCP to the toolkit, returns a connect link when credentials are needed, returns a checkout/top-up link when payment is needed, and requires workspace owner/admin for write operations. The description enriches the annotations and does not contradict them.

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 front-loaded with identity and the core flow, and nearly every sentence carries useful guidance. However, it is one dense, wall-of-text paragraph with mixed language ("pontualmente") and heavy inline emphasis, which makes the many action alternatives hard to scan and 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?

For a complex 23-parameter, 14-action facade with no output schema, the description is remarkably complete: it covers the core flow, one-off invoke semantics, auth/credential/payment behavior, permission requirements, installed flags, the prompt library, and most action outcomes. The main gaps are the resume action and return-shape details for a few actions, but the overall guidance is sufficient for correct invocation in most 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?

With 0% schema description coverage, the description does a lot of compensating work: it maps action values such as search, describe, invoke, install, list_tools, publish_prompt, and explains tool_id, arguments, and prompt-related intent. However, several parameters and enum actions remain unexplained, including resume, limit, immediate, tier_slug, cancel_reason, report_context, conversation, request_name, and request_details, leaving agents under-specified for those paths.

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

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

The description clearly identifies the tool as the official mcp.ai marketplace: the in-platform catalog of MCPs/tools and the way to run them. It states the core discovery→describe→invoke flow, distinguishes the prompt-library subdomain from the MCP flow, and makes it clear this is a marketplace orchestrator rather than one of the sibling calculator/authenticate 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 gives explicit when-to-use guidance: use install only to make an MCP permanent, prefer invoke for one-off use, use list_tools to see what is callable now, use subscribe/cancel for billing, and use request_mcp when nothing fits. It also explains what to do when invoke returns a connect link or checkout link, including retry behavior.

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

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

The description discloses behavior not present in the annotations: CPF/CNPJ are not public court search keys, the service maps CNPJ→razão social automatically, CPF requires the caller to provide nome_titular, and the operation is asynchronous returning { job_id }. These are substantive behavioral traits beyond readOnlyHint/idempotentHint/destructiveHint, and 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 dense but every sentence carries critical information: what the tool does, the name-resolution caveat, the required nome_titular condition, the alternative tool, and the asynchronous polling flow. Key constraints are front-loaded and explicitly marked.

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 job-submission tool with no output schema, the description covers the core lifecycle: input, precondition, async response, and follow-up polling. It is slightly incomplete because the optional scoping parameters (platforms, tribunais, max_results) are not explained and the eventual result payload from processos_get_resultado is not previewed, but the most decision-relevant context is present.

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% property description coverage, so the description must compensate. It does explain the two least obvious parameters—documento as CPF/CNPJ and nome_titular as mandatory for CPF—but it leaves platforms, tribunais, and max_results semantically undiscussed beyond their names and enum/type. This is partial compensation, not full.

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: 'DESCOBERTA por CPF ou CNPJ' and clearly explains the actual behavior—resolving the document to name(s) and searching by name. It also distinguishes itself from the sibling tool by stating the CPF-nome limitation and pointing to processos_buscar_por_nome as the alternative.

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

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

The description states exactly when to use this tool (when you have a CPF/CNPJ), what precondition applies (CPF requires nome_titular), and explicitly names the alternative for the case where the CPF holder's name is unknown: 'Sem o nome do titular do CPF, use processos_buscar_por_nome.' It also gives the follow-up action: poll with processos_get_resultado(job_id).

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?

Discloses asynchronous, slow operation, scraping behavior, and job_id return pattern. Annotations (readOnlyHint, idempotentHint, destructiveHint) are consistent; description adds context beyond annotations without contradiction.

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

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

Three sentences, each adding value: purpose and differentiators, async behavior, enrichment suggestion. No wasted words, front-loaded with key 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?

Covers async behavior and integration with other tools, but lacks details on parameters beyond nome. For a tool with 4 params and no output schema, the description is sufficient for basic understanding but incomplete for full correct invocation without further schema info.

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 description must compensate. Only 'nome' is explained (search by name), but 'platforms', 'tribunais', and 'max_results' are not described at all. The description leaves significant ambiguity about optional 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?

Clearly states the tool searches for legal processes by party name (pessoa or empresa) scraping public court portals. Explicitly distinguishes from siblings datajud (by number) and djen (by OAB/lawyer), fulfilling specific verb+resource and 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?

Explicitly states when to use (search by name, covering a gap not met by datajud or djen) and how to use it asynchronously (call processos_get_resultado for results). Provides clear context and alternative tools.

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

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

Annotations already mark the tool as readOnly, idempotent, and non-destructive. The description goes well beyond annotations by explaining polling behavior, status transitions, degraded 'done' responses, the meaning of vinculacao_nome 'nao_confirmada', and the interpretation of tribunais_inacessiveis. This is rich behavioral context that an agent cannot infer from the schema or annotations alone.

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?

Though dense, every sentence carries operational value. It front-loads the core purpose, states the return structure, gives the polling loop, and then provides essential data-quality warnings. No filler is present, and the structure moves naturally from basic behavior to critical caveats.

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, so the description correctly explains the response fields, statuses, and item contents. It also covers the most important safety caveats around degraded results. The main gaps are the undocumented job_ids parameter and the lack of guidance for what to do on status 'error' instead of only 'done'.

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, but it does not. It never explains job_id vs job_ids, whether job_ids is a batch alternative, how the required job_id is obtained, or how parameters affect polling. The generic phrase 'de um job de busca' is the only hint, which is insufficient for two parameters with zero 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 opens with a specific verb and resource: 'Polling de um job de busca' and explicitly ties the tool to processos_buscar_por_nome/documento. It clearly describes what the tool returns and distinguishes it from the search tools themselves, so an agent can understand its role without confusion.

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

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

The description gives clear operational guidance: 'Continue chamando até done' and 'a busca é lenta', which tells the agent when and how often to call. It also warns about degraded 'done' results and when not to present data confidently. However, it does not explicitly state when not to use the tool or mention any alternative polling mechanism, though the source-tool reference makes the intended context 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 declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds significant value beyond these: it discloses that the tool is ASYNCHRONOUS (returns job_id requiring polling), returns TEMPORARY links that expire (nothing is archived), and notes empty list for processes without public decisions. It also clarifies it's a read-only fetch of public data per CNJ Res. 121/2010. The only minor gap is not detailing auth/captcha specifics beyond a passing mention.

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

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

The description is dense but well-organized: it leads with the core action, then scope limitations, then async behavior and return format, then input sourcing and edge case. Every sentence adds value. Slightly long but for a complex async tool it's justifiable; each clause 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 complex async tool with 4 parameters, 0% schema coverage, and no output schema, the description does substantial work: it covers the async pattern, return payload shape (markdown/pdf_url/expires_at), the polling sibling tool, the CNJ legal scope, and the empty-result edge case. Missing: no explicit explanation of peca_ids and tribunal parameters, and no detail on error cases beyond empty results. Strong but not perfect.

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 carry the full burden for parameters. The description explains numero_cnj (source: processos_get_resultado/datajud) and formato (markdown/pdf implied by conversion to Markdown). However, peca_ids (array) and tribunal are not explicitly explained anywhere in the description. Despite a strong description, these two parameters remain undocumented.

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 downloads public decisions (acórdãos/inteiro teor) from a legal process, converts PDF to Markdown, and returns the decision text with a temporary link. It's very specific about verb (DOWNLOAD/busca/baixa/converte), resource (decisões públicas de um processo), and clearly distinguishes from siblings by stating it does NOT return full case files. The term 'processos_obter_pecas' is made concrete.

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?

Explicitly states when to use (for public decisions), when NOT to use (petitions/documents require lawyer credential), and mentions the polling pattern with processos_get_resultado(job_id). It also specifies the async nature (captcha per search), and guides on using numero_cnj from processos_get_resultado/datajud. This is exceptionally thorough for usage 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 establish read-only/idempotent/non-destructive behavior; the description adds beyond that by disclosing the result shape (excerpts + diary URL). It does not discuss pagination or limits, but this is a minor gap given the strong annotation coverage.

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, front-loaded with the core scope, and every sentence adds value: use cases, DJEN contrast, output summary, and query tip.

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 search tool with no output schema, it already conveys the main purpose, typical uses, and output contents. The main completeness gap is the underdocumented optional parameters, but the core workflow is sufficiently clear.

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 the main required parameter ('termo') and advises quoted exact-name searches, which adds real meaning beyond the bare schema. However, with 0% schema-description coverage, it leaves size, data_fim/data_inicio, and territory_ids without any behavioral or formatting guidance.

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

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

The description clearly identifies a search action ('Busca') over a specific resource ('diários oficiais MUNICIPAIS'), and distinguishes it from DJEN by noting the judicial vs. municipal scope. It also names concrete use cases (licitações, nomeações, contratos, sanções municipais), so the tool's function 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 explicitly says to use this tool for non-judicial municipal gazette mentions and names DJEN as the complement/alternative for judicial content. It also gives a practical query tip: use quotes for exact 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 carry the safety profile with idempotentHint=true and destructiveHint=false. The description adds that conversation data is needed for reproduction, which is useful context. However, it does not disclose what happens after submission, such as whether a ticket is created or whether the report is asynchronous, though the annotations lower 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 consists of two tight sentences: the first states the purpose, the second gives the key usage instruction. There is no filler, repetition, or irrelevant detail.

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

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

For a simple three-parameter reporting tool with annotations already covering idempotency and destructiveness, the description is mostly sufficient. The main gaps are the unexplained `context` parameter and the absence of any indication of what the response or outcome will be, though no output schema is expected.

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 the `conversation` parameter via 'conversation array with recent messages,' leaving the required `message` and optional `context` undefined. The agent must guess at their intended content.

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 opens with the verb 'Report' and explicitly enumerates three targets: 'bug, missing feature, or send feedback'. This makes the tool's purpose unmistakable and easily distinguishable from the sibling calculo_* and authentication tools, which serve entirely different functions.

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 establishes a clear context: use when a user reports a problem or wants to provide feedback. It also adds practical guidance to 'Include the conversation array with recent messages for reproduction.' It does not name alternatives, but none of the sibling tools overlap with bug reporting, so exclusions are unnecessary.

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

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

The annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, non-mutating call. The description adds little beyond that—it names the output as versions but doesn't specify the format (e.g., semver strings, JSON object) or whether the output is human-readable. Since the annotations carry the safety profile, a 3 is appropriate.

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

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

The description is a single sentence of 9 words, front-loading the action ('Show') and the object ('version'). There is zero waste, and it fully conveys the tool's purpose within its scope. This is a model of conciseness.

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

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

For a zero-parameter, read-only, idempotent tool with no output schema, the description is nearly complete. An agent can confidently invoke it without additional context. The only minor gap is that the return format is unspecified, but since there is no output schema, a brief note on the output structure (e.g., 'returns a plain-text summary') would elevate completeness. Still, the description is sufficient 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 tool has zero parameters, and the schema coverage is 100% (no properties). The description doesn't need to explain parameters. The baseline for zero-parameter tools is 4, and the description is consistent with that—it correctly implies that no input is required.

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

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

The description clearly states the tool's purpose: 'Show the current MCP platform and adapter versions.' This is a specific verb-resource pair that distinguishes it from sibling tools, which are all calculation or authentication tools. It could be slightly more explicit about what 'show' returns (e.g., a text summary vs. structured data), but the resource 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?

The description implies that this tool is for checking version information, which makes sense in contexts where an agent needs to confirm platform/adapter versions before proceeding. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention whether version information is needed for authentication or compatibility checks. Given the sibling tools are all calculations, the usage context is reasonably clear, but not explicitly delineated.

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate safety. It adds value by detailing what kind of state is returned, including connection status and account bindings, which helps the agent understand the tool's informational scope.

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

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

A single tightly packed sentence with the main action front-loaded, followed by a colon-delimited list of return contents. Every phrase earns its place with no repetition or filler.

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

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

For a zero-parameter, read-only introspection tool, the description fully covers what the agent needs to know before calling: what information it will receive. No output schema exists, but the description essentially provides a light output contract by enumerating the returned components.

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 is empty with zero parameters, and schema description coverage is 100%, so the description has no parameter burden. Per calibration, zero-parameter tools receive a baseline of 4; the description's output-focused content is more than sufficient.

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

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

The description states a specific verb ('Returns') and resource ('current toolkit state'), then enumerates exactly what is included: installed MCPs, connection status, connected accounts, and catalog tool counts. This is specific enough to distinguish it from computational siblings like calculo_* and action tools like authenticate or connect.

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

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

The description clearly conveys that this is the tool to call when an agent needs an overview or snapshot of the toolkit's current state. It does not explicitly list exclusion criteria or name alternatives such as show_version, but the context is clear enough for routine selection.

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

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

Annotations already mark it read-only, idempotent, and non-destructive. The description adds useful behavioral context: default fase (pagamento), returned fields, and federal-only scope. It does not contradict the annotations, though it omits pagination/ordering 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 dense, well-structured sentences front-load the core purpose and return fields, then end with an alternative-tool pointer. No unnecessary repetition or filler.

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

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

For a 5-parameter tool with no output schema, it covers scope, return fields, default phase, and sibling differentiation. However, parameter semantics are incomplete and it lacks details on pagination/ordering/output structure, leaving meaningful gaps for 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?

With 0% schema description coverage, the description carries the burden but only partially covers parameters. It explains `fase` values and implies `ano`, but omits `pagina`, `ordenacao`, and CPF/CNPJ format. Additionally, 'fase default = 3' conflicts with the schema's string enum, causing ambiguity.

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 it lists item-level expense documents (Empenho, Liquidação, Pagamento) for a beneficiary, with a specific field list. It also explicitly contrasts itself with the sibling tool `transparencia_despesas_favorecido`, distinguishing its granular, item-level 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?

It says when to use this tool (item-level federal expense documents) and provides an explicit alternative for aggregate totals. The 'Só Executivo FEDERAL' scope further clarifies limitations, giving clear context and exclusions.

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

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

The annotations already cover read-only and non-destructive behavior, so the description adds value by revealing aggregation details ('Soma os recursos recebidos e quebra por órgão pagador e por mês') and the default date range behavior. This goes beyond the structured annotations by explaining what the tool actually does with the data. 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 concise and well-structured: it opens with the core purpose, then explains aggregation, followed by an important scope limitation, and ends with the default behavior. Every sentence adds new information without repetition or fluff, making it easy to parse for an AI agent.

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 lack of an output schema, the description reasonably explains the expected output structure (summed totals broken down by paying organ and month). It also covers the tool's jurisdiction, default date behavior, and aggregation logic. It omits error-handling or format specifics, but these are not critical for a straightforward read-only query tool with such clear annotations.

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

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

With 0% schema description coverage, the description compensates by explaining that 'CPF/CNPJ' identifies the beneficiary and 'período' is handled via mes_ano_inicio/mes_ano_fim. It also clarifies that without explicit dates, it defaults to the last 12 months, which gives meaning to the optional date parameters. However, it does not specify the expected date format or validate constraints between start and end dates.

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: 'DESPESAS recebidas por uma empresa ou pessoa (CPF/CNPJ) do Governo Federal' and explicitly describes the aggregation behavior ('Soma os recursos recebidos e quebra por órgão pagador e por mês'). It also differentiates from other tools by limiting scope to the federal executive branch, which helps distinguish it from sibling transparency 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 explicit guidance on scope: 'IMPORTANTE: cobre só o Executivo FEDERAL, não inclui estados nem municípios (cada ente tem portal próprio)', telling the user when not to use this tool. It also explains the default time period behavior ('Sem datas, usa os últimos 12 meses'), which clarifies usage without explicit dates. However, it does not explicitly reference sibling tools or name alternatives within the same portal.

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 that it returns specific data fields (função/órgão/período), which is useful behavioral context beyond the annotations. However, it does not discuss potential edge cases like CPF not found, which would be a minor gap.

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 concise sentences with no filler. It front-loads the core action ('Verifica se um CPF é...') and then adds the return data and use case. 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 single-parameter, read-only tool without an output schema, the description covers the primary purpose, input semantics, return content, and usage context. It lacks explicit error/edge-case handling, but given the tool's simplicity, the coverage is adequate. The sibling context also helps agents understand the tool's niche.

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

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

Schema coverage is 0%, but the description explicitly mentions 'CPF' as the input and states it checks if that CPF is a PEP, thereby adding semantic meaning to the parameter. It does not provide format details (e.g., with/without punctuation), but the core meaning is clear and compensates for the lack of 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 tool verifies whether a CPF is a Politically Exposed Person (PEP) and returns function/body/period. This is a specific verb+resource that distinguishes it from sibling transparency tools (despesas, sancoes) which handle different data.

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 'Importante para compliance/KYC' which gives a clear context for when to use the tool. It does not explicitly list alternatives or exclusions, but the sibling tools are clearly focused on other domains (expenses, sanctions), so the intended usage is well implied.

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?

While annotations already establish that the tool is read-only, idempotent, and non-destructive, the description adds the return structure (a boolean `tem_sancao` and a list with details like type, agency, grounds, and dates). It does not mention potential errors or limitations, but it is not contradictory.

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, using two sentences to convey the purpose, the consolidated sources, and the return value. No extraneous words are present.

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

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

Given the tool's simplicity (a single parameter and no output schema), the description covers the essential aspects: what it does, the data sources, and the output structure. It could be more explicit about the parameter format, but overall it is fairly 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 schema provides no description for the `cpf_cnpj` parameter, and the description only states it is for a person or company, implying it accepts either CPF or CNPJ. It does not specify the expected format (e.g., digits only, punctuation, length). Given zero schema coverage, this is insufficient.

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: it consults sanctions for a person or company based on CPF/CNPJ and specifies that it consolidates multiple sanction lists (CEIS, CNEP, CEPIM). This distinguishes it from sibling tools that deal with expenses or political exposure.

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 due diligence and compliance, and the consolidated nature of the sanction lists suggests it is appropriate for comprehensive sanction checks. However, it does not explicitly contrast with other tools or clarify 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.