Conector Juspronto

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: it discloses that overdue deadlines are included and that three distinct event categories are merged into one response. It does not mention ordering, pagination, or volume limits, but with annotations carrying the safety burden this is 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?

Three sentences, zero filler: content scope first, then usage triggers, then exclusions with alternatives. The most decision-relevant information (what it returns and the sibling exclusions) is front-loaded.

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

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

There is no output schema, so the description must carry the return-value burden, and it does so by enumerating the aggregated categories and noting overdue inclusion. What is missing is the response shape or ordering of the merged agenda items, but for a single-optional-param read tool this is nearly complete.

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

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

Schema coverage is 100%, so the sole parameter 'dias' is fully documented in the schema with default and max. The description only implies a forward-looking window ('próximos dias') and adds no syntax or constraint detail beyond what the schema already provides, making the baseline 3 appropriate.

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

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

States a specific resource (office agenda) and exactly what it aggregates: open deadlines including overdue, hearings, and meetings for upcoming days. It explicitly distinguishes itself from the two nearest siblings, ultimas_movimentacoes (history) and listar_prazos (single process), so an agent can route correctly without opening either schema.

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

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

Gives explicit when-to-use triggers in the user's own phrasing ("o que eu tenho hoje/esta semana?", "o que vence?", "quais as próximas audiências?") and explicit when-not-to-use cases with named alternatives. This is the strongest form of 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?

Annotations already declare readOnly/non-destructive, but the description goes well beyond them: it discloses that this is the slowest call, that it consumes the firm's daily analysis budget (a real rate/cost constraint), that it reads full text or excerpts depending on fit, and that citations are verified against the page. This is exactly the operational context an agent needs before spending budget.

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 tight sentences: the first front-loads what the tool does and what it returns, the second delivers the cost/sequencing guidance. Every clause earns its place with no filler.

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

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

Despite having no output schema, the description explains the return ('a resposta com cada citação conferida contra a página'), the cost profile, and the routing. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema coverage is 100% and the modo enum is already documented, so the baseline is 3. The description adds meaning by explaining the full-text-versus-excerpt behavior ('o texto inteiro quando cabe; senão, os trechos mais relevantes'), which clarifies the operational consequence of the modo choice beyond the raw enum 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?

States a specific verb (answers a question) and resource (a case's autos), and explicitly distinguishes itself from siblings by naming buscar_autos and ler_paginas as the lighter alternatives. An agent can tell what it does and how it differs from the other case-reading tools without opening any schema.

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

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

Gives explicit sequencing ('use depois de processo_status') and a routing rule ('para fato pontual, prefira buscar_autos ou ler_paginas'). Both when-to-use and when-to-prefer-a-sibling are stated directly, leaving nothing to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds the return contract (evidenceId + página) which no output schema provides. It does not mention result limits, pagination or whether queries match across all peças by default, so it stops short of full behavioral disclosure.

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, zero filler. The primary capability and scope lead, and the alternative is deferred to the end where it belongs.

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

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

With no output schema, the description still tells the agent what comes back (trechos with evidenceId and página) and how to escalate to full text via ler_paginas. Nothing essential for correct invocation is missing for a 3-parameter read-only search.

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 100%, so query, processoId and pecaId are all documented in the schema itself. The description adds no syntax or format guidance beyond that (e.g., whether query accepts natural-language questions vs. literal strings, or how pecaId filtering interacts with results). Baseline 3 is correct when the schema carries the parameters.

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

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

Specific verb (busca textual) plus resource and scope: 'nos autos de UM processo', which explicitly narrows it away from the broader sibling buscar_no_acervo. It also states the return shape (trechos com evidenceId e página), so an agent knows what it gets without opening the schema.

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

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

Gives concrete use cases ('localizar citações, CPF, valores e artigos') and an explicit alternative with its own condition: 'para o teor completo de um trecho, use ler_paginas'. The 'UM processo' scoping also implicitly routes multi-process discovery to buscar_no_acervo/buscar_processos.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds real behavioral detail beyond that: results carry an evidenceId ready for chaining into resolver_citacao or ler_paginas, the search is accent-insensitive, and the archive is isolated to this office. It stops short of describing result format or pagination behavior, so it lands just under the top.

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 tightly packed sentences: scope first, then the result/chaining contract, then the alternative tool. No filler, and the most decision-relevant information (scope + alternative) is front-loaded.

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

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

With no output schema, the description helpfully discloses that each result includes an evidenceId for downstream chaining and that the search is accent-insensitive and office-scoped. Combined with fully documented parameters and read-only annotations, an agent has enough to call it correctly, though return-shape details (fields, ordering) remain unstated.

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 100%, so consulta, limite, periodo, tipoPeca, and processoId are all documented in the schema itself. The description adds no parameter-specific syntax or constraints (e.g., what counts as a 'conhecido' process for processoId), so the baseline 3 applies.

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

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

States a specific verb+resource+scope: textual search across ALL of the office's case files at once, and names the exact sibling it differs from (buscar_autos for a single known process). The quoted example queries ('onde já enfrentamos essa tese?') make the intent unambiguous and let an agent distinguish it from buscar_processos or search without opening either schema.

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

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

Explicitly routes the agent: use this for cross-office textual search, but 'Para buscar dentro de UM processo conhecido, prefira buscar_autos'. The scoping rule (a process from another office does not exist here) further clarifies the applicable domain, leaving nothing to inference.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), so the bar is lower. The description still adds real value by disclosing the zero-parameter default behavior and the fact that the returned processoId is the required input for every other tool, which is not inferable from annotations or schema.

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 with the entry-point role front-loaded, then the inputs, then the downstream contract, then the fallback. No filler and no repetition of schema 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?

There is no output schema, and the description covers the essential return contract (processoId plus recent processes when unfiltered). It stops short of describing result field shape or pagination semantics beyond the schema's limite cap, a minor gap for a 5-param discovery tool.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters including the search scope of each. The description restates the same lookup keys with only slightly extra nuance ('com ou sem máscara'), so a baseline 3 is appropriate.

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

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

States a specific verb and resource ('encontre processos') and enumerates the four lookup keys (CNJ number, client name, folder number, free term). It also positions itself as the entry point distinct from siblings that require a processoId, so an agent can tell it apart without opening any schema.

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

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

Explicitly labels itself 'PONTO DE PARTIDA' and names the six downstream tools (processo_status, listar_pecas, buscar_autos, ler_paginas, resolver_citacao, analisar_processo) whose input comes from this call. It also defines the no-argument fallback ('devolve os processos mais recentes'), removing ambiguity about when to call it.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false; the description explains both sides of that profile by disclosing that it writes a conference report and returns a verificationId, while explicitly stating it does not alter the piece or the case files. It also lists the possible verdict outcomes, which no annotation conveys.

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?

Front-loaded with purpose, then usage timing, then side effects and return value, in three dense sentences with no filler. Every clause carries information the agent needs.

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

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

With no output schema, the description compensates by naming the return artifacts (per-claim verdicts with their four categories, and the verificationId cited by the minuta) and by stating the write side effect and its limits. Nothing needed to invoke or interpret the tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents processoId, tipoPeca, claims and textoCompleto. The description reinforces what is checked (evidenceIds, dates, values, required fields of the type) but adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a precise verb and object ('Confere cada afirmação de fato de um rascunho de peça contra os autos') plus the checking dimensions (evidenceId, datas, valores, campos obrigatórios) and the per-claim verdict output. It is clearly a verification/audit tool, distinct from the drafting and retrieval siblings in the list.

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

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

Gives explicit timing guidance: 'Use antes de entregar o rascunho ao advogado e antes de salvar_minuta', which places it in the workflow. It does not name an alternative tool or state when not to use it, so it stops short of the full 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 declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real behavioral value by disclosing exactly what the response contract contains (parties with source, missing fields, required reading, checklist, model pieces), which is more than the annotations convey. It does not discuss permissions, provenance freshness or limits.

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?

Front-loaded with the core action, followed by the payload enumeration and then the usage timing. Every clause carries content and there is no filler, though the long enumerative list makes it denser than strictly necessary.

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

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

With no output schema, the description correctly carries the burden of describing the return contract, and it does so thoroughly. Combined with the explicit usage timing and the fully documented input schema, an agent has what it needs to invoke and interpret the call; only minor details (e.g. failure behavior for unsupported tipoPeca) are absent.

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 100% and every parameter is documented in the schema, including the enum values and the hint to obtain processoId via buscar_processos. The description adds nothing about parameters, so the baseline of 3 applies even though nothing is missing.

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?

States a specific verb (devolve) and resource (contrato de dados de um tipo de peça num processo) and then enumerates the concrete payload: partes com qualificação e FONTE, campos faltantes, peças essenciais, checklist, preferências de redação e peças-modelo. This lets an agent distinguish it from siblings like checar_peca, preparar_secao_minuta or listar_pecas without opening any schema.

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

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

Gives an explicit trigger and ordering constraint: 'Use no início da redação de uma peça, antes de ler os autos.' That is clear when-to-use guidance. It stops short of naming an alternative tool or stating when not to use it, so it does not reach the top of the scale.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond that: this is an aggregator that collapses five separate reads into one, and it explicitly bounds its own scope by deferring page text to other tools.

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?

Front-loaded with the headline value ('FICHA COMPLETA ... em UMA leitura') before the field enumeration, and every clause is informative rather than filler. The caps-lock emphasis and long enumeration make it slightly denser than ideal, but no sentence is disposable.

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 single-param tool with no output schema, the description compensates by enumerating the returned sections in detail and by defining the boundary against full-text navigation. An agent has everything needed to call it correctly and know what to expect back.

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?

Single parameter at 100% schema coverage; the schema already documents processoId and how to obtain it via buscar_processos. With one fully-described param and no added syntax in the description, the baseline for high coverage applies, nudged up because zero parameters need compensation.

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

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

States a specific verb+resource scoped precisely ('A FICHA COMPLETA de um processo em UMA leitura') and enumerates exactly what it returns (CNJ metadata, parties/lawyers, deadlines, next hearing, movements, autos coverage). It explicitly distinguishes itself from siblings by naming the calls it replaces and the tools to use for page content.

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?

Gives an explicit when: use BEFORE navigating the autos. Names the alternatives it substitutes (buscar_processos + listar_pecas + listar_prazos + ultimas_movimentacoes + linha_do_tempo) and routes the agent elsewhere when full text is needed (buscar_autos/ler_paginas). Nothing is left to inference.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so safety is covered. The description adds useful behavioral distinction between the two ID prefixes (processo returns the ficha, pagina returns the page content), which is genuine information beyond the annotations, but it doesn't discuss rate limits, size, or errors.

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

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

A single compact sentence front-loads the purpose and then enumerates the two ID types. Every clause earns its place with 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?

For a one-parameter read tool with an output schema present and annotations covering safety, the description supplies the key routing semantics (which ID prefix yields which result). It doesn't cover edge cases like invalid IDs, but the essential call contract is complete.

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

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

Schema coverage is 100% and the schema already describes 'id' as an opaque value from search. The description adds meaningful semantics by explaining the two prefix forms and what each returns, going beyond the generic schema note, though it doesn't add format details the schema lacks.

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?

States a specific verb (recupera) and resource (conteúdo completo de um ID), and explicitly explains the two ID forms returned by search: processo:<id> and pagina:<evidenceId>. This differentiates it from siblings like search and detalhe_processo by scoping it to fetching content for IDs already produced by search.

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?

Clearly implies usage: retrieve full content of an ID returned by search, with distinct behavior per ID prefix. It doesn't explicitly state when NOT to use it or name alternatives like detalhe_processo or ler_paginas, but the search-produced-ID precondition is a strong usage cue.

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 a safe read (readOnlyHint true, destructiveHint false), and the description goes well beyond them: per-call limits, the pagination continuation contract via has_more, and the non-obvious failure mode that omitting pecaId silently mixes documents and yields wrong excerpts.

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?

Front-loaded with what it does, then usage, then the pagination rule, then the critical warning. No filler; every sentence (limits, continuation, pecaId warning) 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?

No output schema exists, but the description explains the return contract (has_more / proximaPagina) and the key input pitfall. Combined with annotations covering safety, an agent has everything needed 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?

Schema coverage is 100%, so baseline is 3. The description adds real meaning by clarifying that pecaId is effectively mandatory despite the schema labeling it 'opcional', and by binding inicio to proximaPagina for continuation. It adds value over the structured fields without fully documenting inicio/fim beyond the schema.

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

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

States a specific verb+resource ('Lê o texto de uma ou mais páginas') with concrete scope limits (max 8 pages / 40k chars). Its role is distinguished from listar_pecas and buscar_autos, which it names as the sources of pecaId, so an agent can place it correctly among siblings.

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

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

Explicitly says when to use it ('Use após uma busca para ler o conteúdo completo de uma evidência') and gives the continuation rule (on has_more, call again with inicio = proximaPagina; do not recompute). The pecaId prerequisite is stated as a hard requirement.

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

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

Annotations already cover the safety profile (readOnlyHint, destructiveHint=false, openWorldHint=false), and the description adds genuinely useful behavior: the merge across three event types, period scoping, and the notable caveat that peças have no date and are returned separately as pecasSemData. It stops short of describing pagination or the full return shape, so it is strong but not exhaustive.

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?

It is front-loaded with the core action, then usage, then exclusions, then a return-format caveat, and every sentence carries distinct information. The single dense block is slightly long but nothing is wasted, so it sits just below maximal efficiency.

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

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

With no output schema and no annotations gap on safety, the description supplies the essential context: what is merged, ordering, period filtering, and the pecasSemData edge case. It is complete enough to call correctly, though a hint about volume/pagination limits would close the last gap.

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

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

Schema description coverage is 100%, so the parameters (processoId, desde, ate, limite) are already fully documented, giving a baseline of 3. The description reinforces the desde/ate period filter but adds no syntax or semantics beyond what the schema provides and never mentions the limite cap.

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

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

The description states a specific verb and resource ('Monta a linha do tempo de UM processo') and enumerates exactly what is merged (andamentos, audiências, prazos) in chronological order. It also explicitly separates itself from buscar_autos and ler_paginas, so an agent can distinguish it from siblings without opening a schema.

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

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

It gives concrete trigger phrases ('linha do tempo do caso', 'histórico do processo', 'o que aconteceu entre X e Y') and an explicit negative case ('NÃO use para ler o conteúdo das peças'), naming the two alternatives to use instead. When-to-use, when-not-to-use, and alternatives are all present.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds ordering ('mais recente primeiro') and returned fields (version, status, author, review link), which is useful behavioral context. However it doesn't discuss pagination, result size limits, or empty cases. With annotations carrying safety, 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?

Two sentences, front-loaded with what the tool returns, followed by usage routing. No wasted words; the returned-fields list and the pointer to revisar_minuta both earn their 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 read-only list tool with annotations covering safety and a fully documented schema, the description is close to complete: it explains ordering, returned fields, and the intended workflow. Missing minor details like result limits/pagination, but nothing essential for correct invocation is absent.

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 100%, so both parameters (processoId, incluirAntigas) are already documented in the schema, including that processoId comes from buscar_processos and that incluirAntigas defaults to only chain tips. The description adds no parameter detail beyond the schema, which is the baseline 3.

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

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

States a specific verb+resource ('Lista as minutas... do processo') and adds scope detail (most recent first, with version/status/author/review link). Distinguishes from siblings like listar_pecas by specifying 'rascunhos persistidos' and referencing the downstream review flow.

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?

Gives explicit when-to-use: 'Use para achar a minuta PENDENTE antes de revisar (revisar_minuta) ou atualizar.' Names the follow-up tool and the selection condition (finding the pending draft). Does not state when NOT to use or list alternative listing tools, but the positive guidance is clear.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that the result is a structural tree, which is useful, but says nothing about volume, pagination, or return shape. With annotations carrying the behavioral load, 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?

Two short sentences with zero filler: the capability is front-loaded and the usage note follows. Nothing redundant with the title or schema.

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

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

For a simple read-only listing tool with one fully-documented parameter and no output schema, the description covers purpose and workflow placement adequately. It could note whether the tree is complete or paginated, but nothing critical to correct invocation is missing.

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

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

There is a single parameter (processoId) and schema description coverage is 100%, so the schema already documents it fully. The description adds no format, syntax, or sourcing detail beyond the schema, matching the baseline 3 when the schema does the work.

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?

States a specific verb ('Lista') and resource ('peças (documentos) de um processo e a árvore estrutural'), so an agent knows it enumerates documents plus the structural tree. It partially distinguishes itself from siblings by implying it precedes searching/reading pages, but does not name an alternative directly.

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?

'Use para entender a organização do processo antes de buscar ou ler páginas' gives clear when-to-use context and positions the tool ahead of buscar/ler operations. No explicit exclusions or named alternative tools, but the workflow role is clear.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine behavioral value on top: the default sort order, the default of open-only deadlines, and the fact that each item carries 'diasRestantes' and an overdue flag, which matters since no output schema exists.

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

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

Three tight sentences, front-loaded with the verb and filter set, then the default behavior, then the return shape. No filler and every clause carries information.

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

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

With no output schema, the description compensates by naming the returned fields (diasRestantes, overdue flag) and the default ordering. The 'limite' ceiling of 50 and pagination behavior are only in the schema, so the description is nearly but not fully self-sufficient.

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 100%, so all four parameters (dias, limite, processoId, incluirCumpridos) are already documented in the schema. The description names processoId, dias and incluirCumpridos but adds no format, syntax or default detail beyond what the schema states; baseline 3 applies.

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

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

States a specific verb and resource ('Lista prazos') and enumerates the filter dimensions plus the no-filter default ordering. It does not, however, differentiate itself from plausible siblings like 'agenda' or 'linha_do_tempo', which an agent might reasonably consider for deadline-like information.

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

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

Gives clear operational context: filter by processo, by window of days, or include completed items, and explains what happens when no filters are passed (open items nearest to their due date). It stops short of naming an alternative tool or stating when not to use this one.

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

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

Annotations already cover the read-only, non-destructive, closed-world profile, and the description adds substantial context on top: the payload is self-contained (partes, evidenceIds, checklist), results are ordered by nearest deadline and capped at 20, and the write step requires a connection-level minutas permission without which salvar_minuta does not appear. That permission-gating caveat is exactly the kind of behavior annotations cannot express.

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?

Front-loads the core purpose, filter, ordering and limit in the first sentence, with the workflow routing and permission caveat following. It is dense and the permission aside lands slightly out of sequence, but no sentence is filler.

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

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

With no output schema, the description carries the return-shape burden and does so (complete package with partes, evidenceIds, checklist), while also covering the 20-item cap, the ordering rule, the permission prerequisite, and the next-tool chain. An agent has everything needed to call it and act on the result.

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?

Zero input parameters, so there is nothing for the description to disambiguate and the baseline is 4. The description instead explains how the returned minutaProntaId feeds sibling tools, which is useful but concerns output rather than input semantics.

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

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

States a specific verb ("Lista") and a precisely bounded resource (pacotes de Minuta Pronta com status PRONTA_PARA_REDIGIR), plus ordering (prazo fatal mais próximo primeiro) and a cap (até 20). The status filter distinguishes it from the broader listar_minutas sibling without the agent needing to open either schema.

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

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

Gives an explicit trigger condition ("Use no início do prompt 'redigir minutas do dia'") and routes the agent onward by naming the exact downstream tools (dados_para_peca, ler_paginas, checar_peca, salvar_minuta) and the field to pass them (minutaProntaId). This is a full when-and-what-next instruction.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds that it returns the section, its assertions, references, and context, which is useful behavioral context, but it does not disclose auth requirements for this specific read, output format, or rate-limit behavior. A 3 is appropriate given annotations carry the safety disclosure.

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 tightly written sentences with zero waste. It front-loads the read purpose and then appends the necessary save/check workflow, so every 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?

Given that there is no output schema, the description usefully lists the read content (section, assertions, references, context) and situates the tool in a larger workflow. It does not explain output structure or how limiteContextoChars affects returns, but these gaps are minor for a read-only preparation tool whose annotations already cover safety.

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 100%, so minutaId, secaoId, and limiteContextoChars are fully documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, making the baseline 3 correct.

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 ('Lê') and resource ('uma seção da minuta canônica, suas afirmações, referências e contexto') and clearly distinguishes this read/preparation step from sibling tools by naming the save tool (salvar_secao_minuta) and the approval-check tool (checar_peca). An agent can tell this tool is for reading a draft section and its associated material, not for saving or approving.

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 a clear workflow: read the section to draft the alteration, save with salvar_secao_minuta, and check the recomposed document with checar_peca before approving. It does not explicitly state when not to use this tool or contrast it with other read-oriented siblings like dados_para_peca, but the intended context is unambiguous.

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, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds that it returns ingestion status and coverage (pages processed), a light behavioral detail beyond annotations, but with no output schema it could say more about the shape of the result.

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, zero waste: the first defines the function, the second gives the sequencing rule. The purpose is front-loaded and nothing is 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 simple one-parameter read tool with no output schema, the description hints at the return content (ingestion status, pages available) and gives clear usage timing. It is nearly complete, though without an output schema it could formalize what fields the status response contains.

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 single parameter processoId is fully documented in the schema as a UUID, so schema coverage is 100% and the baseline is 3. The description adds no format or semantics for the ID beyond what the schema already provides.

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 ('Consulte') and resource ('status de ingestão e cobertura ... de um processo'), making clear it reports ingestion/coverage rather than performing analysis. It implicitly distinguishes itself from siblings like analisar_processo or resumo_processo, though it never names an alternative explicitly.

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?

'Use antes de qualquer análise' gives explicit timing guidance for when to invoke this tool, which is genuinely helpful for sequencing. It lacks any when-not or named-alternative routing, 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 declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context by disclosing the return shape (full excerpt plus direct page link), which matters because there is no output schema to convey it.

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

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

Two short sentences, purpose first and usage second, with no redundant or filler text. Every clause carries 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 read-only resolver with no output schema, the description covers what it does, when to use it, and what it returns. It omits failure behavior for malformed or unknown evidenceIds, which is the only meaningful gap.

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

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

Schema description coverage is 100% and the single parameter is already documented with an example in the schema. The description restates the evidenceId format (processo://...) but adds no new syntax, constraints, or validity rules, so baseline 3 applies.

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

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

The description gives a specific verb+resource: it resolves an evidenceId (processo://...) and returns the full excerpt plus a direct page link. That is unambiguous, though it does not explicitly distinguish itself from plausible siblings such as ler_paginas or checar_peca.

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 a trigger condition ('Use quando precisar conferir uma citação'), which is genuine when-to-use guidance. However, it names no alternatives or exclusions, leaving the agent to infer why this is preferable to ler_paginas when both touch page content.

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 cover the read-only/safe profile, but the description adds crucial non-obvious behavior: it is instantaneous and consumes no reading budget because the text was pre-computed at ingestion time, and it discloses the staleness signal. This is exactly the kind of operational context structured fields cannot convey.

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

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

Front-loads the primary use case and routes to alternatives in a dense but well-organized block. The 'atualizado false' note is appended as a trailing clause that could be integrated more cleanly, but overall no sentence is wasted.

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

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

Given a one-parameter read tool with no output schema, the description covers purpose, output shape, cost model, staleness behavior, and explicit sibling routing. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100% and the single parameter already documents that the ID comes from buscar_processos. The description adds no further parameter semantics, so the baseline of 3 applies.

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

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

States a specific verb and resource ('devolve o resumo já pronto') and enumerates exactly what the summary contains (partes, pedidos, fase atual, valores, últimos eventos). It explicitly positions itself as 'PRIMEIRA OPÇÃO' and names the siblings it is not (buscar_autos, analisar_processo).

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?

Explicit when-to-use (resuma o processo, do que se trata, me atualiza), when-not-to-use with named alternatives for each exclusion (buscar_autos for specific facts, analisar_processo for verifiable citations), plus an edge-case rule for the 'atualizado false' flag.

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 a write (readOnlyHint=false) that is idempotent and destructive; the description adds real value by explaining the destructive aspect is mitigated ("o texto anterior vai para o histórico") and disclosing the 20k character limit. It does not describe response/confirmation behavior, keeping it below 5.

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 front-loaded sentences with the core action first and supporting detail after; efficient overall, though the character limit is redundantly restated from the schema.

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

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

With no output schema, the description adequately conveys the effect of a successful call (summary saved for office-wide reuse, prior text archived). For a two-param write tool this is essentially complete, with only minor gaps around confirmation/return 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 100%, so both parameters are already fully documented in the schema, and the description merely repeats the 20k limit already stated there. Per the baseline rule for high coverage, a 3 is appropriate.

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

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

States a specific verb and resource ("Grava o resumo que você compilou do processo") and clarifies the effect on the read counterpart ("o próximo 'resuma o processo' volta instantâneo"), implicitly distinguishing it from the read-only sibling resumo_processo. The differentiation is functional rather than naming the sibling outright, so it falls just short of a 5.

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

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

Gives clear when-to-use conditions: "Use no fim de uma leitura longa ou quando o advogado pedir para registrar o estado do caso." It does not name an alternative or state when-not to use it, so it stops short of the 5 bar.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely useful non-annotation context: the opaque result ID format (processo:<id>, pagina:<evidenceId>) and the fact they are consumable by fetch, which tells the agent how to act on results.

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

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

Two short sentences with no filler; the scope statement comes first and the handoff detail second. Every 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?

With a 1-parameter schema, full annotation coverage and an output schema, the description covers what the agent needs to call and chain the tool. The one real gap is disambiguation from the crowded set of sibling search tools, which matters for selection.

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 100% and the single query parameter is already documented with accepted forms (CNJ, cliente, pasta, palavra-chave). The description adds no additional semantics for the parameter, so the baseline of 3 is appropriate.

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

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

States a specific verb and a two-part resource (processos and páginas dos autos), which is clearer than the bare name 'search'. However, it never distinguishes itself from the many overlapping siblings (buscar_processos, buscar_autos, buscar_no_acervo), so an agent cannot tell which search surface to pick.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative among the closely related search tools. The only routing signal is the downstream hint that returned IDs 'podem ser passados para fetch', which helps chaining but not 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 declare readOnly, openWorld=false and destructive=false, so safety is covered. The description adds real behavioral context beyond them: results are returned in reverse chronological order and long descriptions come truncated, which tells the agent the return value is lossy and where to go for completeness.

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 tight sentences, front-loaded with the core behavior, then usage triggers, then the truncation caveat and escape hatch. Every sentence carries information; no filler.

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

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

For a read-only listing tool with no output schema, the description adequately conveys the return shape (chronological movements each paired with a process) and the truncation limitation. The only unaddressed detail is pagination/windowing behavior, a minor gap.

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

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

Schema coverage is 100%, so all three parameters are already documented with defaults and caps (limite 20/50, desdeDias 7/90). The description only echoes the N-day window and the optional process restriction without adding format or semantics beyond the schema; baseline 3 is appropriate.

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

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

States a specific scope and resource: movements in the acervo or a single process over the last N days, in reverse chronological order, each with its process. It also routes away from itself for full text, distinguishing it from buscar_autos/ler_paginas, though it does not contrast with the similar-sounding linha_do_tempo sibling.

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?

Gives concrete triggering scenarios ('alguma novidade?', 'o que movimentou esta semana?') and explicitly names the alternatives (buscar_autos, ler_paginas) for retrieving full document text. No explicit 'when not to use' beyond that, but the routing is clear.

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