Assinafy

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

With readOnlyHint=true already present, the description adds valuable context: validate is side-effect-free ('without creating a document'), validation results need per-item success checks, and ambiguous names should be surfaced to the user. No contradiction with the annotations is apparent.

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, and the key scoping information is front-loaded. The phrasing is dense and slightly packed, but every clause earns its place by describing an action, a boundary, or a workflow 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?

There is no output schema, so the description carries some burden for return behavior; it does disclose the critical 'check each validation result's success' expectation. Combined with schema branch descriptions for list/get/validate, the tool is adequately specified, though a fuller return-shape hint would make it fully complete.

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

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

Schema description coverage is 100%, so the schema already documents action, account_id, include_inactive, include_standard, field_id, and values. The description adds some usage-level meaning like 'match definitions to template placement field_id,' but it does not add significant parameter-level detail beyond what the schema provides.

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

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

The description names three concrete sub-actions with clear verb-object pairs: 'list finds reusable definitions; get inspects one field; validate checks values without creating a document.' This distinguishes the tool from document-creation siblings like prepare_document and request_signatures, and the field-related scope is immediately 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?

The description gives explicit workflow positioning: use it to 'prepare template values' or 'collect field placements,' and specifically 'before requesting signatures.' It also clarifies that validate does not create a document. However, it never names sibling alternatives directly, so the when-not-to-use guidance is implied rather than fully explicit.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the description adds meaningful extra context: explicit user authorization is required, current state should be inspected first, and Assinafy enforces deletion restrictions. This gives the agent important operational guardrails beyond the structured annotations.

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

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

The description is two concise sentences with no filler. The critical authorization caveat is front-loaded, and the inspection precondition is included efficiently. Every sentence contributes actionable guidance.

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 destructive operation with no output schema, the description covers the essential context: authorization, precondition, and domain-enforced restrictions. It stops short of detailing exactly which documents Assinafy permits deletion of, but it instructs the agent to inspect state first, making the tool safely callable.

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

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

The input schema has 100% coverage, and the single parameter document_id is already described as 'unique document ID to delete.' The description adds no additional parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description clearly names the operation 'Delete a document' and identifies the resource. It also adds an important scope qualifier: deletion should only occur when the user explicitly authorizes it. This makes the tool's purpose unambiguous and distinct from the sibling tools.

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

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

The description explicitly states when deletion is permissible: only when the user's instruction explicitly authorizes it. It also advises inspecting the document's current state first, giving the agent a concrete precondition before invoking the tool. Since no sibling tool performs deletion, the usage guidance is complete.

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

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

Annotations include readOnlyHint=true (no mutation) and openWorldHint=true (may perform external calls). The description does not contradict these but adds behavioral context: it warns to wait for certificated status and artifact availability before downloading, and mentions the output format (base64 bytes). It does not disclose potential latency or external dependencies, but the annotation covers the key safety aspects.

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

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

The description is concise (two sentences) and front-loads the core purpose ('Retrieve bytes only when needed') before elaborating on actions. It efficiently packs important conditions (wait for status, availability) and output format (base64) without redundancy.

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

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

Given the tool's complexity (oneOf schema, multiple artifact types, dependency on other tools), the description covers the essential usage prerequisites and output. The schema is rich, so the description doesn't need to explain return values. No significant gaps identified for an agent to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, with detailed parameter descriptions for action, artifact, page_id, and document_id. The description reinforces key semantics (e.g., artifact options are already in schema, but description adds 'default' for original). This adds marginal value beyond the schema, hence baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: downloading documents or pages. It distinguishes between artifact and page downloads, listing specific artifact types and the relationship between page downloads and find_documents. This differentiates it from sibling tools like verify or prepare.

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

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

The description provides clear guidance on when to use this tool: 'Retrieve bytes only when needed' and specifies the prerequisites for each action (wait for certificated status, use page_id from find_documents). It does not explicitly exclude alternatives, but given the tool's unique role among siblings (download vs. verify, delete, etc.), the context is sufficient.

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

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

Annotations already mark the tool readOnly, and the description adds meaningful behavioral context beyond that: it warns that 100% signatures does not mean certification is finished and frames the tool as a prerequisite before retries. It also discloses what kinds of data each action exposes (status, assignment, signer IDs, artifacts, timeline, delivery history). No contradictions with the annotations.

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

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

The description is compact and front-loaded: it opens with the tool's core purpose, then enumerates all four actions in one efficient sentence, and closes with a high-value warning. Every sentence earns its place and no wording 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 read-only inspection tool with no output schema, the description plus schema fully covers what an agent needs: how to invoke each mode, what to inspect before retrying, and the key caveat about certification status. The sibling tools and annotations reinforce that this is the read-before-write inspection step.

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

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

The input schema has 100% description coverage, including per-action schemas and descriptive property fields. The tool description adds goal-level meaning to the action choices but does not add parameter-level detail beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description states the tool finds documents and checks signing progress, and maps each sub-action (list, get, activities, notifications) to a specific resource and purpose. It clearly differentiates the four modes and positions the tool as a read-side inspection tool relative to mutation siblings.

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

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

The description gives explicit routing guidance: use list to search, get to inspect, activities for timeline, notifications for WhatsApp delivery history. It also states when to use the tool overall: read before retrying a send or following up, which distinguishes it from sending/follow-up sibling tools.

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

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

Annotations declare readOnlyHint=true, which the description does not contradict. The description adds behavioral detail: 'Check exact contact details and ask about ambiguous matches' which implies that ambiguous results are possible and the agent should seek clarification. However, other behavioral aspects like pagination behavior or that 'get' requires a signer_id are covered by schema, so the description adds incremental value but not rich context. The description explicitly says to 'ask about ambiguous matches,' which goes beyond annotations.

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

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

The description is concise, at about 30 words, and front-loads the main purpose. The first sentence states the core function, the second contrasts list/get, and the third gives usage advice. Each sentence earns its place, with no fluff.

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

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

Given the simplicity (1 param, schema covers all) and no output schema, the description is quite complete. It tells the agent to check details and ask about ambiguity, which is essential for safe operation. The only minor gap is it doesn't explain what to do if the signer is not found, but that is inferred from 'ask about ambiguous matches.' Overall, it is sufficient for correct invocation.

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

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

Schema description coverage is 100%, so all parameters are described in the schema. The description adds guidance on how to use the action parameter ('list searches the directory; get inspects a known signer'), which complements the schema. However, it does not add details on search/email filtering syntax (schema covers it), and it does not explain pagination beyond the schema. With high coverage, baseline 3 is appropriate.

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

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

The description clearly states the tool resolves a recipient to a workspace signer ID and distinguishes between 'list' (searches the directory) and 'get' (inspects a known signer). This is specific about the verb and resource, and makes a clear distinction from sibling tools like assinafy_save_signer, though it could explicitly name the sibling or contrast with broader search functions.

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

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

The description provides a clear workflow: 'Check exact contact details and ask about ambiguous matches before sending invitations.' It implies usage when you need to resolve a recipient for signing, which is a distinct use case from other tools. However, it does not explicitly state when NOT to use it (e.g., when you only need to verify a document or find templates), but the context is adequate without 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?

Annotations already declare readOnlyHint=true, and the description stays consistent by framing operations as discover/list/inspect. It adds a meaningful limitation: get only works where the compatibility endpoint is supported, and it discloses what list returns so callers can anticipate results. It does not cover error behavior or rate limits, but the read-only safety profile is already handled by annotations.

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

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

Three short sentences, front-loaded with the core purpose and then delivering mode details, sibling guidance, and a scope boundary. Every sentence earns its place, and there is no repetition of annotation or schema content.

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

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

For a two-mode, read-only discovery tool without an output schema, the description covers purpose, the list/get distinction, list return fields, a compatibility caveat, and a related sibling. The schema fills in the remaining defaults and parameter details, so nothing critical appears missing.

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

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

Schema description coverage is 100%, so the schema already documents action, template_id, account_id, search, page, and per_page. The tool-level description maps actions to their outputs but does not add parameter-level syntax, defaults, or constraints beyond what the schema provides. This matches the baseline for a fully covered schema.

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

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

States a specific action and resource: discovering saved templates before requesting signatures. It clearly distinguishes the two modes (list vs get) and lists what each returns, including roles, pages, field_id, and placement labels. It also separates itself from template authoring, making its purpose unmistakable among sibling tools.

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

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

Anchors usage to a clear workflow phase ('before requesting signatures') and explicitly points to check_fields as the sibling for matching field names. It also draws an out-of-scope boundary with 'Template authoring stays in Assinafy.' It could be slightly more explicit about when to choose get over list, but the mode descriptions imply the choice.

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

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

Annotations already indicate destructive and non-idempotent behavior. The description adds that resend may consume notification credits and warns against redundant reminders, providing useful side-effect context beyond the annotations.

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

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

The description is concise, front-loads the purpose, and breaks down each action without redundancy. Every sentence adds value.

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

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

Given the complexity of two actions and the lack of an output schema, the description covers prerequisites, side effects, and a usage caution. It does not describe return values, but the invocation requirements are well specified.

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

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

Schema descriptions cover all parameters (100%). The description reinforces the meaning of action values and reminds to use IDs returned from find_documents, adding context beyond the schema's field-level descriptions.

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

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

The description clearly states it follows up on an existing assignment and enumerates two specific actions (resend, set_expiration) with their effects, distinguishing it from sibling tools like find_documents or request_signatures.

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 instructs to use this after checking find_documents and warns against repeating reminders unnecessarily, providing a clear sequence and a caution. However, it doesn't explicitly state when not to use it relative to other follow-up or signing tools.

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

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

The annotations already mark this as non-read-only and destructive, so the description's job is to add nuance. It does: upload does not send invitations and returns a document ID, and rename is only allowed before an assignment exists. This meaningfully discloses side-effect boundaries without contradicting the annotations.

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

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

The description is three short sentences with no redundant phrasing. It front-loads the core purpose, summarizes both action variants, and ends with next-step guidance, making every sentence informative.

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

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

For a tool with two distinct action branches, the description covers the workflow context, the return value for upload, and the timing restriction for rename. The schema covers remaining parameter details like 25 MiB limit and normalization, so the description is sufficiently complete for an agent to select and invoke the correct action.

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 each branch's parameters described in the input schema. The description maps the high-level actions to their key inputs (PDF bytes for upload, document name for rename), but does not add meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Prepare') and resource ('PDF') and explicitly outlines the two supported actions: upload and rename. It also orients the agent in the workflow by mentioning subsequent tools like request_signatures, making it clearly distinct as a preparatory step.

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

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

The description states the tool is used 'before requesting signatures,' which establishes its position in the workflow. It also differentiates the rename action by noting it only applies 'before an assignment exists,' and directs the agent to continue with find_documents and request_signatures, providing practical routing guidance.

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

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

Annotations only signal non-read, non-idempotent, open-world behavior. The description adds critical behavioral context: these actions 'send invitations and can consume credits', 'wait for processing and creates or reuses email signers', and warns against duplicate assignments. It clearly discloses side effects and post-failure behavior beyond what annotations convey.

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

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

The description is dense but well-organized: it front-loads the core purpose, then walks through each mode in a consistent pattern, and ends with a high-value failure-recovery warning. Every sentence adds non-redundant information and earns its place.

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

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

The description covers the three modes, preconditions, credit consumption, and failure recovery, which is substantial for a complex tool with no output schema. The only gap is that it does not explicitly describe the full return payload, though it hints at the retained document ID. Overall, it is nearly complete for safe and effective 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 100%, so the baseline is 3. The description goes beyond the schema by explaining the strategic meaning of the action discriminator (exactly one source) and the precondition for from_document and from_template parameters. It does not repeat field-level details but adds operational guidance that helps the agent choose and populate parameters correctly.

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

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

The description states a specific verb and resource ('Send a document for signature') and immediately distinguishes the three execution modes: from_pdf, from_document, and from_template. Each mode has a distinct input source and outcome, and the high-level wording differentiates this tool from siblings like find_documents or save_signer.

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

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

The description gives explicit when-to-use guidance: 'using exactly one source', 'inspect the document first and do not repeat an existing assignment', and 'discover roles and field IDs first'. It also provides recovery guidance after partial failure: 'continue from_document instead of uploading again', which names the alternative action and the condition selecting it.

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

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

The annotations already mark the tool destructive, but the description adds operation-level consequences: create sends no invitations, and changing an unverified channel invalidates old links/OTPs. These are non-obvious side effects that materially change how an agent should plan follow-up actions.

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 dense sentences front-load the primary create/update distinction, then add the critical destructive side effect and the follow-up condition. There is no filler, repetition, or unnecessary restating of schema contents.

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 covers the key operation split, duplicate avoidance, destructive side effects, and follow-up timing, while the schema supplies the detailed parameter and verification rules. The main gap is that the description does not state what the tool returns, which is more noticeable because there is no output schema.

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

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

Schema description coverage is 100%, and the schema itself documents parameters with useful details like E.164 normalization, digits-only CPF/CNPJ, and the verification-integrity constraint on email/whatsapp updates. The description adds behavioral context but does not add parameter-level meaning beyond what the schema already provides.

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

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

The description states concrete actions: 'create adds a workspace contact without sending invitations' and 'update corrects a shared contact subject to Assinafy's verification restrictions.' This makes the tool's purpose clear and distinguishes the create and update modes from each other and from the find_signers sibling.

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

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

It explicitly instructs the agent to 'find_signers first to avoid duplicates' before creating, and it conditions follow-up on both a successful correction and user authorization for a reminder. This is prescriptive when-to-use and when-not-to-use guidance tied to real workflow steps.

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

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

Annotations already set readOnlyHint and openWorldHint, but the description adds valuable behavioral context beyond those: it is a public lookup, requires no workspace connection, and sends no credential upstream. This reassures the agent about side effects and authentication needs. It does not detail failure modes or response format, but the annotation coverage lowers the burden.

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

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

The description is two short, purposeful sentences. The core action and key constraint are front-loaded, and the behavioral note about public lookup is added without redundancy. Every clause earns its place.

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

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

For a simple one-parameter, read-only tool with annotations covering safety and openness, the description covers purpose, input, and notable behavioral traits. It does not specify the exact return value or verification result format, and there is no output schema to fill that gap, which prevents a perfect score.

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

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

Schema description coverage is 100%, so the hash parameter is already well documented in the schema. The description adds only marginal nuance by emphasizing the hash must be the 'actual Assinafy SHA-1 signature hash,' which clarifies provenance rather than format or semantics. This meets the baseline but does not significantly exceed it.

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

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

The description states a clear verb ('Verify'), a specific resource ('a signed document'), and the means of verification ('using its actual Assinafy SHA-1 signature hash'). This is clearly distinct from siblings like assinafy_delete_document or assinafy_download_document, and the public-lookup nature further differentiates it from tools that require workspace access.

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

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

The description provides clear context on when to use the tool: it is a public lookup that requires no workspace connection and sends no credential upstream. This implies the tool is appropriate for verifying a hash without authentication setup. It does not explicitly name alternatives or exclusion conditions, so it stops short of a 5.

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