Dilligence — certidões de empresas

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

No annotations are provided, so the description carries the full behavioral burden and mostly fails it: it never states whether the operation is read-only, what permissions or session context are required, or whether any data is mutated. The enumeration of included sections is useful content, but for a tool with zero annotation coverage the mutation/side-effect profile should be explicit.

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 dense sentence that front-loads the core concept (current account) before the enumerated sections. No filler, though the sentence-fragment form and the lack of a leading verb cost it the top score. It also switches language relative to the English tool names and siblings, a minor readability tax.

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, the description is the only documentation, and it names the sections but not their shape or how they relate (is this a dashboard summary, settings, or raw account record?). For a zero-parameter, no-schema tool the description is adequate to identify the resource but not complete enough to predict what comes 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?

The input schema declares zero properties and zero required parameters, so there is nothing for the description to disambiguate. Baseline 4 applies for a parameterless tool. Nothing in the description misleads about inputs.

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

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

The description enumerates what the account resource surfaces (credit balance, members, keys, statement, payment) which is more than a restatement of the name. However, it uses a noun-phrase label ("Conta atual:") rather than a verb, so it never states whether this reads, creates, or aggregates anything. An agent can guess it is an account overview but cannot tell from the text how it differs in operation from list_* or check_payment 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?

There is no when-to-use guidance and no exclusions. Several siblings overlap directly on the concepts named (buy_credits and check_payment for payment/credits, create_api_key for keys, invite_member for members), and the description does not say whether this tool is the summary view or should be preferred over those. The agent has to infer routing entirely.

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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that this is a mutation on an open diligence and that certidões wait for fetch_certidoes unless fetch=true, but it does not cover permissions, duplicate handling, or side effects.

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

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

The description is compact and front-loaded: it opens with the core action and then explains the relevant input distinctions. Every sentence adds useful information without 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 six-parameter mutation tool with no annotations and no output schema, the description is fairly complete: it covers purpose, parameter meaning, party scoping, and the fetch behavior. It still omits authorization expectations, duplicate behavior, and outcome details.

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

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

With 0% schema description coverage, the description compensates well: it explains party_ids as coming from get_diligence.parties, certidoes as IDs from list_catalog, documents as free titles with an example, title as a single free document title, and fetch as an alternative to fetch_certidoes.

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: adding documents to the list of an already-open diligence. It distinguishes certidoes (IDs from list_catalog) from documents (free titles such as contrato social), though it does not explicitly distinguish itself from the sibling upload_document.

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 usage conditions: use an already-open diligence, apply to all companies or restrict via party_ids from get_diligence.parties, use certidoes IDs from list_catalog, and use fetch=true or rely on fetch_certidoes. It lacks explicit when-not-to-use guidance versus siblings like upload_document or request_documents.

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?

No annotations exist, so the description carries the full burden, and it does disclose the two things that matter most: the call consumes credits and it has a state side effect (resumes the search). It omits irreversibility, failure behavior, and what happens if the item has no pending fee, which keeps it from a 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?

Two compact clauses with the action first and the cost warning immediately after; the CETESB credit-cost example earns its place by making the pricing model concrete. 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 two-parameter mutation with no annotations and no output schema, the description covers the consequence and the prerequisite but not the parameters or the result state. Adequate to act on, but an agent still has to guess what the IDs are and what comes 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?

Schema description coverage is 0%, so both item_id and diligence_id are undocumented in structured data and the description must compensate. It only implies item_id via 'para um item' and says nothing about diligence_id — its provenance, format, or relation to the item — leaving half the parameters uninterpretable.

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 — approves the agency fee for an item — and adds a second effect, resuming the search, which an agent could not infer from the name alone. It is clearly distinct from siblings like buy_credits or check_payment, 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?

The clause 'Gasta créditos: confirme com o usuário antes' gives a real precondition (user confirmation before spending), which is more than most descriptions offer. However, it never says when this tool applies versus check_payment or buy_credits, nor what to do if credits are insufficient, so usage is implied rather than spelled out.

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

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

With no annotations, the description carries the full burden. It usefully discloses a real side effect — an external assignee receives a submission link and an email only when send_email=true — but says nothing about whether an existing owner is replaced, what permissions are required, or whether notifications go to internal members.

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

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

A single sentence that front-loads the action and packs the parameter detail efficiently, with no filler. The density is justified by the undocumented owner parameter, though the nested parenthetical makes it slightly harder to scan.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema coverage, the description covers the hardest part (owner formats) but leaves two of three parameters and key behaviors (overwrite semantics, permissions, member notification) unaddressed.

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

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

Schema coverage is 0% and the owner property has no type at all, so the description must compensate. It does an excellent job documenting the three owner formats ('me', 'u:...' member id, and the external {name,email,send_email} object), but diligence_id and item_id remain completely undocumented in both schema and description.

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

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

The description states a specific verb+resource: it sets the responsible party ('responsável') for an item, which is distinct from sibling tools like invite_member or remove_item. It is clear what the tool does, though it does not explicitly name a sibling it replaces or is distinguished from.

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

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

Usage is implied by the name and by the enumeration of valid owner forms, but there is no explicit when-to-use/when-not-to-use guidance, no mention of alternatives such as invite_member for adding people to the workspace, and no stated prerequisites.

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

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

With no annotations, the description carries the full burden, and it does disclose two important behaviors: retry consumes credits, and items that don't fit the action are skipped and counted in 'skipped'. It does not cover permissions, whether 'remove' is reversible, or what null owner does at scale beyond the parenthetical.

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 dense sentence, front-loaded with the action enumeration and followed by the skip-count behavior. Efficient with no filler, though the nested parentheticals make it slightly harder 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 5-parameter mutation tool with no annotations and no output schema, the description covers the action semantics, credit cost, and the 'skipped' output field reasonably well. It still leaves diligence_id undefined and says nothing about permissions or the irreversibility of 'remove'.

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

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

Schema coverage is 0%, so the description must compensate. It fully explains the action enum and the owner parameter (including null to clear), and implicitly covers reason via 'na' com reason and item_ids via 'vários itens'. diligence_id is never explained, leaving a required parameter undocumented in both schema and description.

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

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

The description states a specific verb+resource — applying one action to many items — and enumerates the four supported actions with their meaning. It implicitly parallels the single-item siblings (assign_item, retry_item, mark_not_applicable, remove_item) by referencing 'owner como em assign_item', but never explicitly contrasts bulk vs single-item use.

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

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

Usage is implied through the action enumeration: the agent can infer which action value maps to which intent. However, there is no explicit 'use this when acting on many items, use X for a single item', and no statement of prerequisites or when-not-to-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?

With no annotations, the description carries the burden and mostly does: it discloses that the tool creates a Stripe link rather than charging, that the saved card arrives pre-filled, and that a session_id must be carried forward to check_payment. It omits link expiry, idempotency/duplicate-link behavior, and failure modes, which keeps it from a 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?

Dense and largely front-loaded: purpose and pricing come first, then the workflow, then the pre-condition. The instruction to ask the user about the package is placed last when it logically comes first, a minor structural inversion, but 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?

There is no output schema, so the description must convey return shape — it does by naming checkout_url and session_id and their roles. For a single-parameter tool this is nearly complete; only error/expiry behavior 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% with an enum, so the baseline is 3; the description earns above baseline by mapping each enum value to a price (10 → R$ 80, 30 → R$ 200, 80 → R$ 500), which the schema does not encode. That price mapping is what the agent needs to confirm the package with the user.

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 ("Cria um link de pagamento do Stripe") plus the concrete outcome (user buys a credit package) and the exact tiers. An agent can immediately distinguish it from siblings like check_payment or list_catalog.

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: ask the user which package first, hand the checkout_url to the user (don't pay yourself), then call check_payment with the session_id. It names the follow-up sibling and the condition for calling it, which is exactly the when/when-next guidance needed.

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

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

With no annotations, the description carries the full burden and does disclose two important traits: the tool mutates state (credits the balance) and does so idempotently ('uma vez só'), which tells an agent repeated calls are safe. It omits what happens when payment is absent or pending, whether authentication beyond session_id is needed, and any error behavior, so the disclosure is partial rather than complete.

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

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

A single front-loaded sentence with the action first, followed by the idempotency caveat and the return values. No filler, 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?

Although there is no output schema, the description names the three return fields (paid, credited, balance), which covers the return contract. What remains missing is the failure/pending path and any auth or rate expectations, which matter for a state-mutating, likely-polled tool.

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

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

The schema has one required parameter (`session_id`) with 0% description coverage, and the description never explains what the session id is, where it comes from, or how it relates to the buy_credits flow. With coverage this low, the description should compensate but does not.

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

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

States a specific verb pair (check payment, credit balance) on a specific resource, and ties itself to the sibling buy_credits link, so an agent knows this is the post-purchase verification step. It stops short of contrasting with other credit/account siblings like `account`, but the purpose is unmistakable.

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

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

The phrase 'pagou o link de buy_credits' implies the tool should be called after invoking buy_credits to confirm payment, which is useful implied usage. However, there is no explicit when-to-use/when-not guidance, no mention of polling cadence, and no pointer to an alternative if the payment hasn't landed.

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

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

With no annotations, the description carries the full burden. It does disclose one high-value behavioral fact — the key is shown only in this response, i.e. it is unrecoverable afterward — but says nothing about key scope/permissions, expiry, rate limits, or whether it requires elevated auth.

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 terse sentences with zero waste; the irreversibility warning is placed immediately after the purpose statement, front-loading the most important fact.

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 usefully says where the key is returned, but for a credential-minting mutation it omits scope, expiry, and the "only once" consequence beyond the moment of creation. Adequate but thin.

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

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

Schema coverage is 0% and the single parameter "label" is documented nowhere. The description never explains what the label is for (display name? uniqueness? length constraints?), so it fails to compensate for the gap.

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

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

States a specific verb+resource ("Cria outra chave de API") and clarifies the intended consumer ("para outro agente ou sistema"). It is clearly distinguishable from revoke_api_key by the create/mint action, though the sibling is never named.

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

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

The parenthetical "for another agent or system" implies the use case (provisioning credentials for a separate caller), but there is no explicit when-not guidance, no mention of revoke_api_key as the counterpart, and no stated prerequisites or limits.

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

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

With no annotations, the description carries the full burden and meets it: it discloses that the call only assembles the list (no requests are dispatched), when the external requests actually start, and the billing model – 1 credit per issued certificate, charged only on issuance, with uploaded documents free. These are exactly the side-effect and cost facts an agent needs before invoking a mutating tool.

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 compact and information-dense with no filler sentences; every clause conveys a rule, a default, or a cost. It is slightly packed, stacking purpose, parameter semantics, sequencing, defaults and billing into a single paragraph, but nothing 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?

For a mutating tool with no annotations and no output schema, the description covers preconditions (match_documents), side effects (list only, fetching deferred), defaults, and cost. What it omits is the return value (e.g., whether a diligence id comes back) and any permission or limit constraints, which matters somewhat for a creation call.

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

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

Schema coverage is 67% and the description meaningfully fills gaps: certidoes are ids from list_catalog, documents are titles of anything outside the catalog (contrato social, balanço, alvará), and the semantics of omitting both are spelled out. The template parameter's interaction is only partly covered ("certidoes e documents somam a ela" is in the schema, not the description), and name/cnpjs are unaddressed.

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 – it opens a diligence for a set of CNPJs with a document list – and explicitly distinguishes it from fetch_certidoes ("Só monta a lista: os pedidos aos órgãos começam quando você chama fetch_certidoes"). The purpose is unambiguous, though the opening sentence is followed by a dense mix of behavioral detail that dilutes the front-loading slightly.

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

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

It gives explicit when-to-use rules: run match_documents first and confirm the list with the user if there is a checklist, pass fetch=true only if the user already asked to fetch, and if neither certidoes nor documents is given, all catalog certificates are included. Alternatives (fetch_certidoes, match_documents) are named with the conditions that select them.

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

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

With no annotations, the description carries the full burden. It usefully discloses the e-mail side effect (send=true triggers a message to a person) and that item_ids reuses existing items from a diligence, but it says nothing about permissions, what object is created and returned, or what happens on duplicate/invalid cnpj.

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?

Five short clauses with the purpose front-loaded and no filler; each sentence carries branching logic. The telegraphic style ('certidoes e documents como em create_diligence') is dense but borders on under-specification rather than verbosity.

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

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

For an 8-parameter mutation tool with zero annotations and no output schema, the description covers the main decision tree but omits return behavior, failure modes, and the meaning of two parameters. Adequate to attempt a call, not complete enough to call confidently.

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

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

Schema coverage is only 13% (only 'to' documented), so the description must compensate: it explains the shape of 'to', the diligence_id/item_ids relationship, and the cnpj standalone mode. However it defers certidoes/documents to 'as in create_diligence' rather than defining them, and leaves message and name completely unexplained.

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

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

The opening verb+resource ('Faz um pedido de documentos') is specific, and the description immediately branches into the two request modes (to="robot" for agency certificates vs. to={name,email} for a person via link). It also references create_diligence for the certificate/document vocabulary, which helps an agent separate it from list_requests and create_diligence, though it never explicitly states what those siblings do differently.

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 selection conditions: use "robot" to request certificates from agencies, use {name,email} to request from a person, and only set send=true for e-mail if the user explicitly asked. It also distinguishes the in-diligence path (diligence_id, item_ids) from the standalone path (cnpj). No exclusions against sibling tools like request_documents are 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?

No annotations are provided, so the description carries the whole behavioral burden. It does disclose the key side effect that enable_share turns on the read/share link and describes the contents of the archive, which is genuinely useful. It does not say whether the resulting share link is public or persistent, whether permissions are required, or what happens when the diligência has no documents.

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 output artifact and the column list are stated up front and the enable_share condition closes it. The column enumeration ('situação, resultado, validade, código, protocolo, resumo e link') is slightly long but earns its place since there is no output 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 correctly describes the return value as a link to a ZIP plus a spreadsheet and enumerates its columns, which is exactly what an agent needs to report back. Missing only edge-case behavior (empty diligência, expired link, failure mode) to be fully complete for a two-parameter export tool.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It fully explains enable_share (boolean that turns on the read link when it is off) and implicitly scopes diligence_id to the diligência whose documents are exported, but gives no format, ID-type, or validation hints for the required 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 names the deliverable precisely: a ZIP containing all documents of the diligência (Documentos/ folder) plus an .xlsx with one row per document and a defined column set. It is not phrased as an action verb and never contrasts with siblings such as read_document or share, but the artifact it produces is unambiguous and no other sibling produces exports.

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 one concrete conditional: 'Usa o link de leitura; se estiver desligado, passe enable_share=true para ligá-lo', which is real operational guidance for the optional parameter. However, there is no statement of when to export versus reading documents individually (read_document) or fetching a single diligência (get_diligence), and no prerequisites or exclusions.

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

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

No annotations exist, so the description carries full behavioral burden; it does disclose the non-obvious monetary side effect ("Gasta créditos quando a certidão sai") and mandates user confirmation, which is valuable. It omits what happens to items already requested or ineligible, failure/idempotency behavior, and what the call returns, which is a meaningful gap for a costly mutation with no 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?

Front-loads the action and keeps to roughly two sentences, with the credit warning placed at the end where it is most visible. The parenthetical "ou só item_ids" is syntactically awkward and slightly obscures the parameter-mode distinction.

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

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

For a no-annotation, no-output-schema mutation that spends money, the description covers the cost side effect but leaves the return value, the effect on already-requested items, and valid item_ids sourcing unexplained. The schema also documents nothing, so the definition is only minimally sufficient to call this safely.

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

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

Schema description coverage is 0% for both parameters. The description only obliquely explains item_ids ("ou só item_ids (também repete as que pararam)") without stating format, where to obtain valid IDs, or whether an empty/missing value means all ready items; diligence_id is never described at all. This does not adequately compensate for a completely undocumented 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?

Names a concrete verb ("Pede aos órgãos" / request from agencies) and a concrete resource ("certidões da diligência"), and scopes it to certificates not yet requested (status "ready"). It does not explicitly name an alternative among siblings such as request_documents or retry_item, even though the "repete as que pararam" clause overlaps with retry_item, so it falls 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 a clear trigger condition: request certificates with status "ready" that haven't been requested, or restrict to specific item_ids (including re-running stopped ones). It also adds an important precondition — confirm with the user unless they explicitly asked to fetch, because credits are spent — but offers no explicit exclusion or named alternative tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses some return content (item status, responsible, result, links, app_url), but does not state that the operation is read-only, what auth is required, or how missing/invalid ids behave.

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

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

The description is one short sentence with no filler, but it is an unstructured field list and does not front-load the tool's action. Its brevity comes at the cost of clarity.

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

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

For a detail-getter with no annotations and no output schema, the description should state what it retrieves and what id means. It only lists some response fields, which is not enough for reliable invocation.

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

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

The only parameter is a required string id, and the description never explains whether it is a diligence id, item id, or UUID. With 0% schema description coverage, this leaves the parameter materially 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 is a noun-phrase inventory of returned fields rather than a verb+resource statement; it never says it retrieves a diligence by id. An agent can infer the purpose from the tool name, but the description alone does not clearly distinguish it from siblings like list_diligences or get_item.

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

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

There is no when-to-use guidance, no prerequisites, and no routing to alternatives. Nothing says to use this for a single diligence detail versus list_diligences for collections or get_item for an individual item.

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

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

With no annotations, the description carries the full burden, but it does usefully disclose the returned payload (including history and attempt counts), which compensates for the missing output schema. It says nothing about permissions, read-only nature, error behavior when item_id/diligence_id are invalid, or payload size.

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

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

A single front-loaded sentence with no filler; the field enumeration is dense but every element conveys what the agent will receive. Slightly list-like rather than structured, but efficient.

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

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

It adequately sketches the return payload given that no output schema exists, but with zero annotation coverage and 0% schema parameter documentation, the definition leaves the caller without required-parameter semantics or safety/auth context.

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

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

Schema description coverage is 0% and neither of the two required parameters (item_id, diligence_id) is mentioned in the description. It is left entirely to the agent to guess the identifier format and the relationship between the two IDs.

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

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

The description states a specific resource (an item) and the retrieval intent ('Detalhe completo'), and enumerates the fields returned (summary, stop reason, protocol, next check, fee, attempts, history). This distinguishes it from list-oriented siblings like list_diligences, though it never explicitly contrasts with get_diligence.

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

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

There is no guidance on when to call this versus get_diligence, list_requests, or bulk_items — an agent must infer it from the name. No preconditions, no mention of what happens if the item belongs to a different diligence.

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

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

With no annotations, the description carries the full burden and does well: it discloses the access level granted (view and edit all diligências) and the external side effect (an invitation email is sent). It omits failure modes such as what happens when the person is already a member, which keeps it from a 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?

Two short sentences, zero waste, with the purpose and permission scope front-loaded ahead of the usage constraint. Nothing is redundant with the tool name 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 one-parameter, no-output-schema tool, the description covers purpose, granted permissions, the email side effect, and a consent guard — enough to call it correctly. It could add duplicate-member behavior, but no annotations exist to fill any gap, so this is close to 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 description coverage is 0%, so the single 'email' property is undocumented in the schema. The description only implicitly signals that the parameter is the invitee's address via 'Convida alguém' and 'Envia e-mail de convite'; it never states the expected format or whose address it is explicitly.

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 ('Convida alguém para o workspace') and adds the resulting permission scope ('vê e edita todas as diligências'), so an agent knows exactly what the call accomplishes. It does not explicitly distinguish itself from the inverse sibling remove_member or from share, but the verb makes the intent 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 clause 'só use se o usuário pediu' is an explicit, actionable when-to-use restriction that prevents proactive inviting — exactly the kind of gating an agent needs for a side-effecting action. It stops short of naming alternatives or stating when-not-to-use conditions beyond user consent.

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

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

With no annotations, the description carries the burden and does disclose two useful traits: the feature is early access, and the call requires no authentication. It is silent on idempotency (what happens if the email is already listed), whether a confirmation is sent, and whether the write is reversible — meaningful gaps for a mutation tool.

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

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

Three short clauses, and the operational instruction is easy to extract. The leading clause is partly product framing rather than invocation guidance, which is mild padding but not serious 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 simple two-parameter, no-output tool this covers the essentials: what it does, auth status, and a usage gate. Missing are the outcome of the call and duplicate-handling behavior, which the agent may need when a user has already signed up.

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 50%: the optional 'note' parameter is documented in the schema itself, while 'email' is self-explanatory by name. The description adds no meaning beyond the schema, but the remaining gap is small for a two-parameter tool.

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

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

States a concrete action (add the user's email to the early-access waitlist for continuous CNPJ monitoring) and names the resource. The verb+resource pairing is clear, though it never explicitly separates itself from close siblings like wait_for_changes or signup.

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?

"só use se ele pediu" is an explicit gating condition telling the agent not to call it unprompted, which is exactly the kind of guidance that matters for an opt-in list. It does not name an alternative tool or explain what to do if the user wants monitoring but has not asked to join the list.

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

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

With no annotations, the description carries the full burden and does well: it discloses the credit cost (1 crédito per emitted certificate), the 24h reuse rule, and that failures are not charged. The cnpj filtering behavior is also described. It stops short of describing the response shape or what fields are returned per entry, which keeps it from a 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?

The description is dense but every clause earns its place: catalog contents, cnpj scoping, id-family semantics with an example, and billing rules. Content is appropriately front-loaded with what the catalog contains, though the id-family explanation is somewhat compact for an unfamiliar reader.

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

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

For a no-annotation, no-output-schema, single-optional-param tool, the description covers the catalog contents, filtering, id semantics for downstream use, and cost behavior. The main gap is the absence of an explicit action statement and any hint of return structure, but overall an agent has enough 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% for the single cnpj parameter, so the schema already documents it. The description restates the filter ('só as certidões que valem para esta empresa') and adds only the 'pela sede na Receita' detail, so it adds marginal value over the structured field. 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 clearly establishes the resource: a catalog of certificates (certidões) with their órgão, validity, fee, and automatic-emission status. The verb 'list' is only implicit ('Certidões que buscamos'), but the scope is concrete enough that an agent knows it returns the certificate catalog rather than executing a diligence. It also names create_diligence, helping distinguish its role.

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 links its output to create_diligence, explaining that 'trt'/'trf' family ids can be passed as id while regional ids (trt15, trf1) target a specific court, with a worked example (TRT-15 for a Campinas branch). That is real when-to-use guidance, though it never states flatly 'call this to discover available certificates before creating a diligence' or any exclusion.

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

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

With no annotations and no output schema, the description carries the full burden, and it does disclose that results include progress information. However, it says nothing about ordering, pagination, result size, or whether the list is scoped by permissions/workspace membership.

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

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

A single front-loaded sentence with no filler. It is arguably too terse rather than too long, but 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 zero-parameter list tool with no output schema, the description covers purpose and hints at returned content, but leaves the shape of the response, ordering, and volume unclear — details an agent would want before deciding to call it.

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 takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies.

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

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

States a specific verb and resource (list diligences) plus scope (workspace) and a distinguishing attribute ('com progresso'), which separates it from get_diligence's single-item fetch. It stops short of saying what a 'diligence' record contains, but the operation itself 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?

No guidance on when to use this versus get_diligence or the related list_requests/list_templates tools. The agent must infer that this is the browse-all entry point and get_diligence the detail fetch.

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?

No annotations are provided, so the description carries the full behavioral burden. It hints at returned content ('com o que já chegou') and request channels, but does not state read-only behavior, permissions, pagination, ordering, or side effects.

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

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

The description is short and front-loads the resource ('Pedidos do workspace'). It is dense but not bloated; clarity issues come from vagueness rather than verbosity.

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

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

For a list tool with no annotations, no output schema, and an undocumented boolean filter, the description is incomplete. It explains the general subject but leaves the agent without critical parameter semantics and behavioral details.

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

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

The sole parameter, open_only, has 0% schema description coverage and is not mentioned anywhere in the description. The description adds no meaning beyond the bare parameter name.

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

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

The description identifies workspace requests and divides them into requests to people and to agencies, with received status, so the resource is understandable. But it does not explicitly say it lists requests or differentiate the tool from siblings such as remind_request or list_diligences.

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

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

The phrase 'Use para acompanhar e cobrar' gives an implied monitoring/follow-up use case. It gives no exclusions, prerequisites, or comparison with alternative tools, so guidance remains minimal.

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

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

With no annotations, the description carries the full burden and does well: it discloses the substitution rule (SP certificates swapped for local TJ/SEFAZ documents outside SP, only for that company) and describes exactly what is returned (items, adjustments, suggested model). It omits whether the operation is strictly read-only or any rate limits, 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?

The core purpose is front-loaded, but the single dense paragraph with nested parentheticals (the 'onde não buscamos' aside) is harder to scan than it needs to be. Most content earns its place, but the the structure could be tighter.

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 only 50% param coverage, the description steps in to explain the return structure (items, adjustments, suggested template) and the scope of adjustments. It is largely complete, though it leaves the read-only nature and optionality of parameters implicit.

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

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

At 50% schema coverage, the description compensates: it explains that cnpjs drives the per-company adjustments ('para quais cnpjs') and that name drives the suggested template ('modelo sugerido pelo nome da diligência'). That adds real meaning beyond the schema's terse field 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 identifies the resource: ready-made due diligence templates already adjusted to each CNPJ's registered location (TRT/TRF regions), returning items, per-location adjustments and a suggested template. It distinguishes the output shape well. It does not state the verb 'list' explicitly, but the intent is unambiguous.

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

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

It gives explicit timing: 'Use antes de create_diligence com template', naming the sibling that follows. That is a clear use condition tied to a specific alternative. It does not state when-not to use it, so it stops short of 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?

No annotations are provided, so the description carries the full burden. It does not say whether the marking is reversible, whether it affects diligence scoring/completion, or whether the counterparty is notified — all material for a state-mutating tool on a diligence item.

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 with the action and the required reason front-loaded; nothing wasted, though there is very little content to structure.

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?

A mutation tool with no annotations, no output schema, and 0% parameter documentation should do more: it should explain the resulting item state, side effects, and the role of diligence_id vs item_id. As written, an agent cannot call it confidently without guessing.

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

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

Schema description coverage is 0%, and the description only glosses one of the three required parameters ("com o motivo" for reason). diligence_id and item_id are left entirely undefined in both schema and description, so the description only partially compensates for the coverage gap.

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

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

States a specific verb (mark) plus the resource (item) and target state ("não se aplica"), which is genuinely distinguishable from siblings like remove_item or assign_item. It stops short of explicitly contrasting with those siblings, so it is clear but not differentiating.

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 indication of when to use this instead of remove_item, retry_item, or bulk_items, and no preconditions (e.g., item state required to mark it not-applicable). Usage is only inferable from the name of the state being set.

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?

No annotations are provided, so the description carries the full burden. It discloses the output semantics (empty source_ids = document someone must send) and the accepted input forms, but never states that the call is non-mutating, what happens on unmatched items, or any size/format limits on base64 uploads.

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 the capability first and the workflow position last; nothing is decorative. Slightly tighter phrasing could have made the text-vs-base64 choice explicit without lengthening it.

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, the description does describe the return shape (per-item source_ids, empty meaning unmatched), which is the key piece. It is still incomplete on the input-mode decision and on failure behavior for a 3-parameter tool with two alternative input channels.

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 33% and only content_base64 is documented in the schema. The description adds real value by naming checklist sources (pasted checklist, e-mail, spreadsheet, base64 photo), but it never covers 'filename' and never explains precedence or exclusivity between 'text' and 'content_base64', which is the most likely invocation error.

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: it reads a requested-documents checklist and maps each entry to catalog certificates (source_ids), or flags it as empty when a human must send it. This is clearly distinct from read_document (which reads one file) and from add_document/create_diligence. It stops short of a 5 only because the two input modes are named rather than explicitly contrasted.

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 positions the tool in the workflow: 'Use antes de create_diligence ou add_document', naming the siblings it feeds. That is clear ordering guidance, though it gives no when-not-to-use conditions or prerequisites (e.g., catalog must exist).

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

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

With no annotations, the description carries the full burden. It does disclose the return payload shape (text, result, validity, code) and the important side effect that include_file=true embeds a base64 PDF, which implies payload size cost. It does not say what happens if no document exists for the item, nor any auth/permission requirements.

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

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

Two sentences, no filler. The primary action and return contents come first, and the optional file-embedding flag is called out last with its exact semantics ('em base64').

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 or annotations, so the description does the work of describing the return values, which it does reasonably well. However, for a tool that fetches potentially large binary payloads, it omits error cases (missing document) and confirms nothing about the relationship between diligence_id and item_id.

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

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

Schema description coverage is 0%, so the description must compensate for three params. It explains include_file=true concretely (attaches the PDF in base64), but item_id and diligence_id receive no semantic explanation beyond their names, leaving two of three parameters 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?

States a specific verb ('Lê') and resource ('o documento de um item'), and scopes it to either an issued certificate or an uploaded file. It also enumerates what is returned (full PDF text, result, validity, code). It does not explicitly distinguish itself from siblings like get_item, fetch_certidoes, or export_documents, so not 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?

Usage is implied by the resource scoping (reading a specific item's document), but there is no explicit guidance on when to prefer this over get_item (item metadata) or export_documents/fetch_certidoes (bulk/collection retrieval). No prerequisites or exclusions are 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?

No annotations are provided, so the description carries the full burden. It does disclose the key side effect — an actual email is sent to a person and its content is derived from what is still pending — plus a user-consent guardrail, which is more than the name alone. However, it says nothing about re-send throttling, required permissions, what happens if nothing is pending, or whether the request state changes.

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

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

One compact sentence with the action front-loaded, then the id source, then the guardrail — every clause carries information and there is no filler. The only weakness is that the provenance parenthetical interrupts the guardrail, slightly muddling the closing constraint.

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 tool with no output schema and no annotations, the definition conveys the action, the id source and the consent condition, which covers the essentials. It leaves out what the tool returns, whether requests without pending items are rejected, and any rate limiting — meaningful for an outbound-email tool but not blocking 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?

Schema description coverage is 0% for the single parameter, so the description must compensate, and it does so on the most important ambiguity: it tells the agent the request_id comes from list_requests, providing provenance for an otherwise bare string. What is missing is only format/example detail, a minor gap for a single opaque id.

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?

Names a specific verb+resource combination ('Manda de novo o e-mail de um pedido' = resend a request's email), which is clearly distinct from sibling tools like create_request, list_requests and request_documents. The parenthetical pointing to list_requests as the id source further disambiguates it, though it never explicitly contrasts itself with those 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?

'Só se o usuário pediu' is an explicit consent-based usage constraint that tells the agent when it must NOT self-initiate the tool, which is unusually valuable for an outbound-email action. It also directs the agent to list_requests for obtaining the id, giving a concrete pre-call step, but stops short of naming alternatives or state prerequisites.

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

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

With no annotations, the description carries the full burden, and it does disclose one real side effect: a certificate not yet requested from the agency is cancelled rather than merely unlisted. It is silent on permissions, reversibility, and what happens to items already requested — significant gaps for a destructive mutation.

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 the core action front-loaded and the conditional side effect immediately after. No filler, though the Portuguese-only wording is a minor usability tax in an otherwise English tool set.

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 two-required-param mutation with no annotations and no output schema, the description explains the action and one conditional outcome but omits parameter meaning, permission requirements, and response behavior. Adequate to start, not sufficient to call confidently.

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

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

Schema coverage is 0%, so the description must compensate, yet it never mentions diligence_id or item_id, their formats, or where the IDs come from. The prose only loosely implies that both a diligence and an item must be identified.

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 ("Tira um documento da lista da diligência") that clearly separates it from siblings like add_document, assign_item, and remove_member. The name says "item" while the description says "documento", a small terminology drift, but the intent 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?

Usage is only implied: it removes a document from a diligence's list. The second sentence hints at a case distinction (a certificate not yet requested is cancelled), but no alternative tool (e.g. mark_not_applicable, retry_item) or when-not-to-use condition is named.

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

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

No annotations are provided, so the description carries the full burden. It does not state that removal is destructive/irreversible, what permissions are required, whether the member loses access immediately, or what happens to resources they owned — all critical for a destructive mutation.

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 short sentence with the scope front-loaded and no filler. It is efficient, though the parenthetical is slightly elliptical ('id de account.members' is terse rather than explanatory).

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 destructive tool with no annotations and no output schema, the description should cover required permissions, irreversibility, and the result of the call. None of that is present, leaving an agent to guess at the consequences of invoking it.

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

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

Schema coverage is 0% and the single parameter 'user_id' has no description in the schema. The description partially compensates by pointing to 'account.members' as the source of the id, but it does not specify the expected format (UUID, email, numeric id) or whether it is the membership id versus the user id.

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?

Names a specific verb ('Tira' / removes) and resource ('um membro do workspace'), so the operation is unambiguous. It does not explicitly contrast with the sibling invite_member, but the verb alone makes the direction of the operation clear.

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

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

There is no guidance on when to use this versus alternatives, no prerequisites (admin role?), and no note about what happens to the removed member. The only usage hint is the parenthetical about where the id comes from, which is parameter guidance rather than tool selection 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?

No annotations are provided, so the description carries the full burden, and it discloses nothing: not that this is a mutation, not whether the rename is idempotent or reversible, not whether the name must be unique among diligences, not what permissions are needed, and not what is returned.

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 words is short but this is under-specification rather than conciseness — there is nothing front-loaded because there is nothing to front-load. Nothing in the sentence earns its place beyond restating the name.

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

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

The tool itself is simple (2 required string params, no nesting, no output schema), which lowers the bar, but with zero annotation coverage and zero schema descriptions the description is the only channel for behavioral and parameter context and it supplies none of it.

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, and it does not mention either parameter. Neither 'diligence_id' (which diligence identifier format, where to obtain it) nor 'name' (constraints, length, uniqueness) receives any explanation beyond the bare 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?

"Renomeia a diligência" does state a specific verb (rename) and resource (diligence), so the intent is recoverable. But it adds nothing beyond what the tool name 'rename_diligence' already encodes, and it is written in Portuguese while every sibling tool name and the rest of the catalog are in English.

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

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

There is no guidance on when to use this versus alternatives such as create_diligence or get_diligence, and no prerequisites (e.g. must the caller own the diligence?). The single sentence gives context only implicitly through the verb.

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

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

With no annotations, the description carries the burden and does meaningful work: it discloses the return value (a submission link), a key property (no login required for the recipient), and the side-effect rule that e-mail is only dispatched when send_email=true. It stops short of stating permission requirements, whether prior requests are replaced, or rate 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?

Three short sentences, each carrying distinct information: what it does, what it returns with its access property, and the one conditional side effect. Zero padding and 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?

It covers the two biggest unknowns for a mutation tool with no annotations and no output schema — the returned link and the conditional e-mail. However, four of five parameters remain unexplained, including the required email field whose relationship to send_email is ambiguous, leaving real gaps for an agent to fill.

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% across five parameters, so the description must compensate — yet it only explains send_email ('Só envia e-mail se send_email=true'). The roles of diligence_id, item_ids, name, and email (required, but apparently not always used for delivery) are entirely 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?

Specifies a concrete verb and resource — requesting multiple document items from an external party — and adds a clarifying example ('o financeiro da empresa'). It is distinguishable from most siblings, though the near-neighbour create_request is never named, so the boundary is left implicit.

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?

Implies the usage scenario (collecting items from someone outside the org) but gives no explicit when-to-use/when-not rules and never routes the agent between this, create_request, and remind_request. The send_email conditional is the only explicit usage 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?

No annotations are provided, so the description carries the full behavioral burden and does not meet it. It says nothing about whether a retry consumes credits (a relevant risk given the buy_credits sibling), whether it is synchronous or queued, whether the prior failed result is discarded, or what permissions are needed.

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 short sentence with the action front-loaded and the conditions grouped in a parenthesis; nothing is wasted. It is perhaps too terse for a two-required-parameter tool, but not padded.

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

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

With no annotations, no output schema, and 0% schema coverage, the description should explain at minimum what the two IDs identify and what happens on retry. It leaves both parameter meaning and retry side effects unaddressed.

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

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

Schema description coverage is 0% and neither parameter is documented. The text only hints at an item ('item que falhou'), leaving item_id unexplained in format and diligence_id entirely unmentioned, so an agent gets no help beyond the parameter names.

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

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

The verb phrase 'Busca a certidão de novo' makes the re-fetch/retry action explicit despite the name saying 'item' and the description saying 'certidão'. It is distinguishable from get_item and fetch_certidoes by the 'de novo' emphasis, though the noun mismatch (item vs. certidão) adds a little ambiguity.

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 parenthetical names three concrete triggering conditions: an item that failed, one that stalled ('parou num muro'), or one being renewed. That is clear context for when to invoke it, but it never states when not to use it or names a sibling alternative such as get_item or fetch_certidoes.

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?

No annotations are provided, so the description carries the full burden. It implies a destructive mutation but does not disclose whether revocation is permanent or reversible, whether it takes effect immediately, or what happens to existing integrations using the key.

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 short sentence with the action front-loaded and no filler. It is efficient, though the brevity is achieved partly by omitting information rather than by tight editing.

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 destructive mutation with no annotations, no output schema, and undocumented parameters, the description should explain effects, permissions, and irreversibility. It supplies only the identity of the target resource, which is insufficient for safe invocation.

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

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

Schema coverage is 0%, so the description must compensate. The parenthetical '(id de account.keys)' does add meaning by indicating the key_id comes from the account.keys collection, which helps the agent source a valid value, but format and example values 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 states a specific verb ('Revoga') and resource ('uma chave'), which clearly distinguishes it from the sibling create_api_key. It is unambiguous about what operation is performed, though the phrasing is minimal and leaves no room for scope details.

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

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

There is no guidance on when to use this tool versus alternatives, no preconditions (e.g., ownership or admin rights), and no warning about confirmation before revoking. The agent must infer usage entirely from the tool name.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does explain the external effect of enabling: anyone with the link can view items and download PDFs without login, which is valuable context. However, it omits permissions required to toggle the link, whether changes are reversible, and what the response looks like.

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

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

A single, front-loaded sentence that efficiently states the action and its consequence. The parenthetical explanation is useful and not wasteful, though the sentence is somewhat long and could be split for clarity.

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

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

For a simple two-parameter toggle with no output schema, the description covers the core purpose and effect. However, without annotations and with undocumented parameters, it lacks necessary details about permissions, return values, and parameter semantics, leaving the agent with gaps to fill by inference.

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 implicitly maps 'diligência' to diligence_id and 'liga/desliga' to enabled, but never names or explains the parameters explicitly, leaving their exact semantics 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 states a specific verb-resource pair: toggling the diligence's read link. It also clarifies the link's effect (view items, download PDFs, no login), making the tool's purpose immediately clear. However, it does not distinguish this tool from siblings like get_diligence or create_diligence, so it misses the top score.

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

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

The description explains what the tool does but offers no explicit guidance on when to use it versus alternatives. There is no mention of prerequisites, when-not scenarios, or sibling tools that might be more appropriate, leaving usage entirely implicit.

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

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

With no annotations, the description carries the full burden and discloses key behavior: no authentication required, account creation with 10 free credits, returned api_key/mcp_url/app_url, and an email notification to the user. It omits error conditions, email uniqueness rules, and security caveats around the returned API key.

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 four short sentences, front-loads the core action, then covers returns, auth requirements, and the email side effect. There is no redundant or wasted text.

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

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

For a signup tool with no annotations and no output schema, the description adequately covers purpose, return values, authentication, and the email notification. However, given low parameter coverage and no annotations, it should say more about the name and agent_name parameters and about failure/duplicate-account 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 only 33%, so the description should compensate. It mentions only the email parameter ('com o e-mail dele'), leaving name and agent_name undocumented in the description; agent_name has a brief schema description, but name remains unexplained.

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

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

The description states a specific verb and resource: 'Cria a conta do usuário' (creates the user account), plus the credited benefit of 10 free credits/certidões. It is clearly distinct from sibling actions such as account management or create_api_key, as it describes initial registration.

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 says 'Funciona sem autenticação' (works without authentication), which is useful context for when the tool can be called. However, it does not explicitly compare against alternatives like account or create_api_key, nor does it state what to do if an account already exists.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that PDFs of certidões are parsed and yield resultado/validade/código, but says nothing about permissions, size limits, duplicate handling, overwrite behavior, or failure modes for a mutation tool.

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

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

Two compact sentences with the core action and the parsing side-effect front-loaded. Each sentence earns its place, though the parsing note could be tightened.

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 partially offsets the rich-but-undocumented schema by naming formats and hinting at extracted certidão fields. Still missing: parameter roles, required-vs-optional expectations, and any indication of what is returned on success or failure.

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

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

Schema coverage is 0%, so the description must compensate for five undocumented parameters. It only clarifies the file_url/content_base64 choice implicitly; item_id, diligence_id and filename are entirely unexplained, as is whether the two source params are mutually exclusive.

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 ('Anexa um arquivo') and resource (file to an item), plus accepted formats and the two upload channels. It does not differentiate itself from the sibling 'add_document', which an agent could easily confuse with an upload tool.

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

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

No guidance on when to use this versus 'add_document', 'read_document', 'match_documents' or 'export_documents'. The choice between file_url and content_base64 is stated as an option but with no conditions for picking 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?

With no annotations, the description carries the full burden, and it does disclose the key trait: a blocking call bounded at 45 s, plus the loop termination condition. However, it never says what a 'change' payload looks like, what happens on timeout with no changes, or any error/permission behavior, leaving real gaps for a polling primitive.

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

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

Three short sentences, zero filler, and the most decision-relevant fact (45 s bounded wait) is front-loaded ahead of the cursor mechanics and the loop rule.

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 two-parameter polling tool with no annotations and no output schema, the description covers the invocation loop but not the return contract or the required `id` semantics. An agent knows how to call it repeatedly but not what it will receive or what to pass as `id`.

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

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

Schema coverage is 0%, so the description must compensate. It explains the `cursor` parameter well (value returned by the previous call), but the required `id` is only implicitly identified as the diligence by the phrase 'na diligência' — no format, source, or whether it is the diligence or item id.

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 with scope: waits up to 45 s for changes in the diligence, which identifies it as a long-poll operation distinct from one-shot readers like get_diligence or get_item. It never names a sibling explicitly, so the differentiation is inferable rather than stated.

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 a concrete protocol: pass the cursor from the previous call and repeat while items are 'fetching' or 'waiting'. That is clear operational guidance on how and when to loop. It does not contrast with the non-blocking alternative (get_diligence), which keeps it below a 5.

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