zsign

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

Annotations only indicate non-read-only and non-idempotent behavior. The description adds meaningful context: it requires Authorization, returns a checkout_url, and explains that the webhook credits within seconds. It doesn't contradict annotations and provides useful operational detail beyond the structured fields, though it doesn't cover failure cases or edge behavior.

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

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

The description is two sentences with no filler. The core action is front-loaded, and every clause adds value: pack options, output, payment method, auto-crediting, and auth requirement. It is a model of concise, structured tool documentation.

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

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

For a single-parameter tool with an output schema (indicated in context), the description fully covers what an agent needs to call it: the action, the parameter values, the returned field ('checkout_url'), the interaction flow (pay and auto-credit), and the required authorization. Nothing essential is missing.

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

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

The schema has no description for the 'pack' parameter (0% coverage). The description compensates fully by enumerating the valid values ('starter', 'growth', or 'scale') and directing to get_pricing for details. This gives the agent precise semantic guidance without needing the schema to be enriched.

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 specific action: 'Create a Stripe Checkout session for a credit pack', and lists the exact pack options ('starter', 'growth', or 'scale') with a pointer to get_pricing. This distinguishes it from siblings like check_balance or get_pricing, providing a precise verb-resource-scope combination.

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

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

It gives a clear usage flow: create session, pay, and the webhook credits the account. It also references get_pricing for pack details, implying that the agent should consult pricing first. However, it does not explicitly state when NOT to use this tool (e.g., when credits are insufficient on an existing account), so it falls short of a 5.

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

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

Annotations already mark this as read-only and idempotent; the description adds an important authentication requirement ('Authorization: Bearer zs_...') and states that the response reflects current balance plus available packs. It doesn't cover error behavior, but for a safe read operation with an output schema, this is useful 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?

Two short sentences with no filler: the first front-loads what the tool returns, the second states the auth requirement. Every sentence earns its place and there is no redundant restatement of the tool name.

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

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

This is a simple zero-parameter tool with an output schema and read-only/idempotent annotations, so the description only needs to convey purpose and the auth prerequisite, both of which are present. It stops short of explaining when to choose it over billing siblings, but that gap is covered under usage guidelines.

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

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

There are no input parameters to document, so the empty schema plus 100% coverage leaves no ambiguity. The only parameter-like constraint is the auth header, which is mentioned in the description rather than in the schema. Baseline for zero-parameter tools is 4.

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 a concrete resource ('credit balance and available packs') and pairs it with the imperative title 'Check Credit Balance', so an agent knows this is a read query for current balance/credits. It doesn't explicitly contrast with siblings like get_pricing or buy_credits, but the resource is distinct enough.

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

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

The only contextual cue is a required Authorization header, which is an invocation prerequisite, not a selection rule. No guidance is given on when to call this instead of get_pricing or buy_credits, and there are several billing-related siblings in 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?

Annotations only mark this as a non-read-only, non-idempotent, non-destructive operation. The description goes well beyond that by disclosing side effects (account + API key creation), the lack of email verification, optional email purpose, the 'zs_live_' key prefix, the required Authorization header, and the 0-credit initial state. This is rich behavioral context that annotations do not provide.

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 deliver the core purpose, authentication usage, and next-step workflow with no filler. Each sentence earns its place, and the most important information—account and API key creation—is front-loaded.

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

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

Given there is an output schema, the description does not need to describe the return value. It covers prerequisites (none), credential usage for all other tools, initial credit state, and the immediate next actions. The tool is fully callable and integrable from this description alone.

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 adds real meaning for email ('optional, receipts/recovery only'), but it says nothing about the name parameter beyond what the schema's 'Name' title already implies. Because one of two parameters gains semantic context while the other remains minimally documented, a 3 is appropriate.

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

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

The description states a specific verb and resource: 'Create a zSign account and API key in one call.' It also clearly separates this tool from siblings like get_pricing and buy_credits by framing it as the account-provisioning entry point. Including the API-key creation detail removes any ambiguity about what the tool returns.

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 strong contextual guidance: account creation requires no email verification, and new accounts start with 0 credits, followed by 'call get_pricing then buy_credits next.' It stops short of explicitly stating when not to use this tool or naming alternative account-related tools, but the flow is clear enough for an agent to sequence correctly.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds fresh behavioral context: incomplete envelopes error, the PDF is returned as base64, and an Authorization Bearer token is required. This goes beyond the structured annotations without contradicting them.

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

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

Four short sentences deliver purpose, parameter provenance, failure mode, return format, and authentication requirement. Every sentence adds value, and the primary purpose is front-loaded. There is no filler or repeated 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 single-parameter read-only tool, the description covers the key operational facts: what it downloads, when it is valid, what input to use, what errors occur, the return format, and the required auth. The output schema exists, so explaining return shape in detail is unnecessary. Nothing critical is missing.

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

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

The schema only defines document_id as a required string with no description, so 0% schema description coverage. The description compensates fully by specifying that document_id must be the original document_id from send_envelope / get_envelope_status / list_envelopes, and explicitly excludes completed_document_id. This is essential disambiguation that the schema alone cannot provide.

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

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

The description uses a specific verb-resource pairing: 'Download the standalone Certificate of Signature PDF for a completed envelope.' This clearly distinguishes the tool from the sibling download_signed_document, which downloads a different artifact. The statement about using the original document_id rather than completed_document_id further sharpens the tool's identity.

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

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

The description gives clear when-to-use context: only for completed envelopes, and it explicitly warns that incomplete envelopes produce an error. It also states which source to use for document_id. However, it does not explicitly name an alternative such as download_signed_document, so the reader must infer the comparison from the certificate wording.

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

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

The annotations already declare the operation read-only and idempotent, so the description adds meaningful operational context beyond them: it specifies that the response is base64-encoded and that an Authorization header with a Bearer token is required. This is useful behavioral information that the annotations do not convey.

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

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

Three concise sentences deliver the essential facts in order: the resource, the critical parameter source, the response format, and the authentication requirement. There is no filler, and every sentence adds functional 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?

For a single-parameter read-only tool with an output schema and safety annotations, the description covers everything an agent needs to invoke it correctly: the resource, the parameter provenance, the return encoding, and the authentication requirement. No critical information is missing.

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

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

The schema has zero description coverage for completed_document_id, but the description fully compensates by explaining where the value comes from and explicitly excluding the original document_id. This gives the agent the exact provenance and a concrete negative example, which is far more than the bare 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 opens with a specific verb and resource ('Download the sealed, signed PDF'), making the tool's function immediately clear. It also disambiguates the required input from the original document ID, distinguishing this tool from get_envelope_status and reinforcing its purpose as the retrieval endpoint for the final signed 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?

The description gives clear, actionable usage guidance by stating that the tool requires the completed_document_id from get_envelope_status and explicitly warns against using the original document_id. However, it does not explicitly spell out when to choose this tool over other siblings, so it stops short of a 5.

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

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

Annotations already mark the operation as read-only and idempotent, so the description's additional behavior about envelope states is valuable. It discloses that completed envelopes include the completion certificate while voided/declined/expired ones have an empty certificate, and that active envelopes are not found. The authentication requirement is also stated. No contradiction with annotations.

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

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

Three sentences with no filler; the core purpose is front-loaded, followed by key behavioral edge cases and the auth requirement. Every sentence adds information not available elsewhere.

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 an output schema and read-only/idempotent annotations, the description covers all essential calling context: purpose, envelope-state behavior, required input, and authentication. The only minor omission is a precise definition of 'original document_id', but that is acceptable.

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

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

The schema provides no description for document_id (0% coverage), so the description must compensate. It does by specifying that the original document_id is accepted, clarifying which identifier to use. It does not explain format or type, but it gives the key semantic distinction.

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

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

The description identifies the tool as returning a JSON audit trail for an envelope, which is a specific resource and distinct from sibling tools like get_envelope_status or download_certificate. It also specifies the input (original document_id), making the purpose unambiguous.

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

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

The description provides clear context on when an audit trail is available: completed envelopes include a persisted certificate, voided/declined/expired envelopes return a trail with an empty certificate, and still-active envelopes are not found. It does not explicitly name alternative tools or state when not to use this tool, so it falls short of a 5.

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

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

The readOnlyHint and idempotentHint annotations already establish safety. The description adds valuable behavioral detail: the specific pieces of status returned and the conditional presence of completed_document_id after completion. It also discloses the required Authorization header, which is not captured in the schema.

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

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

One concise sentence packs the return payload, the conditional behavior, and the auth requirement with no filler. The most important information is front-loaded.

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

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

For a simple read-only status endpoint with an output schema and one required parameter, the description covers the essential behavioral and auth context. The mention of the downstream download_signed_document tool also completes the workflow 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?

The schema has 0% description coverage for document_id, and the description does not explicitly define that parameter. However, the parameter is a single required string named Document Id, and the description's context around envelope progress makes its role reasonably inferable. It adds little semantic value beyond the schema.

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

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

The description clearly states what the tool reports: envelope session status, per-recipient signing status, and the completed_document_id when available. It also differentiates itself from the sibling download_signed_document by noting the completed_document_id is meant to be passed to that tool.

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

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

The description gives practical context: get envelope status first, and once completed, the returned ID feeds into download_signed_document. It does not explicitly list exclusions or when-not-to-use scenarios, but the relationship to a named sibling provides strong usage guidance.

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

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

The description adds 'No authentication required', a behavioral trait not present in the annotations, and clarifies the billing model. Since annotations already declare readOnlyHint and idempotentHint, the description supplements them with a useful operational detail. There is no contradiction between the description and annotations.

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

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

The description is a single 12-word sentence with every clause carrying meaning: the resource, the conversion factor, and authentication requirement. It is appropriately front-loaded with the core purpose and contains no redundancy or filler.

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

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

For a zero-parameter, read-only tool with an output schema, this description is complete. It covers the purpose, the critical credit-to-envelopes relationship, and the authentication requirement, leaving no gap for an agent to call it correctly. The output schema handles return-value details, so no further explanation is needed.

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

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

The tool has zero parameters and the input schema covers everything, so the description has no obligation to explain parameter meanings. The baseline for zero-parameter tools is 4, and the description does not need to add anything here. Its note about authentication is behavioral, not parameter-related.

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

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

The description identifies the resource, credit packs and billing model, and the defining conversion factor (1 credit = 1 envelope send), making it clear that this tool returns pricing information. It lacks an explicit action verb, but the tool name 'get_pricing' provides the verb, and the content differentiates it from buy_credits and check_balance.

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 context that implies usage, such as the credit-to-envelope conversion and 'No authentication required', which indicates this is a low-stakes informational call. However, it does not explicitly state when to choose this over buy_credits or check_balance, nor does it name any alternatives or exclusions. Usage must be inferred from the tool name and sibling names.

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

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

Annotations already mark the operation as read-only and idempotent. The description adds the authentication requirement and clarifies that the returned data belongs to the currently authenticated account, which is useful context 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 extremely concise, stating exactly what is returned and the required authorization in two short sentences. Every word serves a purpose and the most important information is front-loaded.

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

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

Given the tool's simplicity, the read-only annotations, and the presence of an output schema, the description covers all necessary context. The only extra requirement, authentication, is explicitly stated, making the definition complete for a zero-parameter retrieval tool.

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

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

The tool has zero parameters, and the schema fully covers this with an empty properties object. Per the baseline for no-parameter tools, the description does not need to compensate for missing parameter documentation.

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

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

The description clearly identifies the resource: this account's referral code and shareable referral link. While there is no explicit verb in the description, the title supplies 'Get', and the resource is distinct enough from sibling tools to avoid 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 description states an important prerequisite, the `Authorization: Bearer zs_...` header, which helps the agent know when the call can be made. It does not explicitly discuss when to use this tool versus alternatives, but the referral-link resource is unique among the listed siblings, so the omission is minor.

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 signal read-only and idempotent behavior, and the description adds meaningful behavioral details: auth requirements, unsent draft inclusion, inclusive date filtering, limit defaults, and output linkage to get_envelope_status. This goes well 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 dense but well-organized, front-loading the core purpose and then enumerating filters, limits, and special behaviors. Every sentence adds meaningful information without redundancy or filler.

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

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

The description covers authentication, filtering, pagination, draft behavior, and the relationship to a sibling tool. With an output schema present and annotations confirming safety, nothing essential is missing 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 0%, so the description carries the full burden for parameter meaning. It thoroughly explains status values, q substring semantics, ISO-8601 date formatting, inclusive created_at filtering, and limit max/default. Only offset is left implicit, but its purpose is inferable from the pagination context.

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 operation ('Search the caller's envelopes') and specifies the resource, making the tool's purpose unambiguous. It further distinguishes itself from sibling tools by noting that it returns document_id values for use with get_envelope_status.

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

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

The description provides strong usage context by detailing available filters, pagination limits, and the relationship to get_envelope_status. It does not explicitly exclude alternative tools, but the scope and downstream use case are clearly implied.

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

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

Annotations give only idempotentHint=false, but the description adds substantial behavioral detail: each success increments reminder_count, a second call within REMINDER_DELAY_HOURS yields 429, REMINDERS_ENABLED does not apply, and Authorization is required. This goes well beyond the structured fields and makes side effects and rate limits 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?

The description is dense but every sentence earns its place: purpose, endpoint, policy context, exception, idempotency warning, and auth requirement. The key action is front-loaded, and no filler or repetition exists.

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 state-changing tool with side effects and rate limiting, the description covers all operational essentials: when it applies, when it refuses, what side effects occur, error behavior, and authentication. An output schema is present, so return-value details are not required in the description.

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

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

Schema has 0% parameter descriptions, so the description must compensate. It does: document_id and recipient_id appear in the endpoint path, making their roles clear, and override_send_invite is semantically explained in the sentence about send_invite=false envelopes. Slight room remains for explicitly stating that document_id is the envelope/document identifier, but the context suffices.

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

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

Description opens with the exact action: 'Send one signing reminder to a still-unsigned recipient,' specifying the verb, resource, and condition. The wrapped endpoint and reminder-specific wording clearly distinguish this from sibling tools like send_envelope or void_envelope, which involve other lifecycle actions.

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

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

Provides clear when-to-use context: target recipient must still be unsigned, and it explains policy constraints such as cap, spacing, and sequential can_sign_now. It also gives explicit when-not conditions for send_invite=false envelopes. However, it does not name alternative sibling tools or contrast them directly, so the guidance stops short of full 5-level routing.

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

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

The description goes well beyond the sparse annotations by disclosing that sending costs 1 credit, default recipients come from draft creation, status changes to Sent, invite emails fire unless disabled, and sequential behavior controls send timing. It also notes the required Authorization header. This gives the agent a clear picture of side effects and prerequisites.

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: the purpose, cost, defaults, effects, and auth requirement each earn their place. There is no redundant restating of the tool name or obvious filler.

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

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

The description covers the main behavioral context: credit cost, recipient defaults, status change, email behavior, sequential flag, and authentication. Since an output schema exists, return-value documentation is not required. The only notable gaps are the semantics of send_completion_email and metadata, which are minor for typical usage.

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

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

The input schema has 0% description coverage, so the description must compensate. It does clarify recipients, sequential, and send_invite, but it does not explain send_completion_email or metadata at all, even though both are parameters with defaults. This is adequate for core usage but leaves some parameters 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 clearly states the action ('Send') and the resource ('a previously created Draft'), which distinguishes it from sibling tools like send_envelope that target envelopes rather than drafts. It also conveys the operation's place in the draft lifecycle.

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 'previously created Draft' implies this tool should be used only after a draft exists, and the contrast with send_envelope is implicit through the resource type. However, the description does not explicitly say when not to use this tool or mention alternatives such as send_envelope or update_draft.

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 only sparse annotations (readOnlyHint=false, destructiveHint=false), the description carries the transparency burden and delivers richly: it discloses the 1-credit cost, PDF rejection when tags are missing, that each recipient gets a signing email, that tags are deleted on upload and never appear in the final document, that party must match the recipient role, and that draft mode debits no credit. It also reveals side effects like webhook echo of metadata and the sequential signing default. No contradiction with annotations.

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

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

The description is long, but the tool genuinely warrants it: field-tag syntax, radio group semantics, and draft-vs-send interplay cannot be compressed further without losing operational necessity. It is well-organized (send/draft behavior, input formats, tag syntax with examples, metadata, sequential) and the correct usage is front-loaded. It is slightly redundant in the radio visible-text rule, stated twice, and could trim a few words.

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

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

For a high-complexity tool (12 params, dual mode, tag syntax, cost side effects) the description covers the full send workflow, draft workflow, failure conditions (rejection, tag requirements, size cap), post-call behavior (polling), auth, and links to docs and a sample PDF. An output schema exists, so return-value documentation is unnecessary. Remaining gaps are minor: send_invite/send_completion_email semantics and filename behavior are left to 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 — and it does for the critical parameters: recipients (exact array shape with name/email/role), document_base64 vs document_url (either-or, 10MB limit), auto_send/draft (full semantics including precedence 'draft=true always wins'), metadata (flat, max 50 keys, webhook echo), and sequential (ordering semantics). However, four secondary parameters (name, filename, send_invite, send_completion_email) receive no semantic explanation beyond their 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 description opens with a specific verb+resource: 'Send a PDF for legally binding signature, or leave it as a Draft for a human to approve.' It captures the tool's dual-mode behavior and differentiates it from siblings like send_draft (send an existing draft) and get_envelope_status (poll progress). An agent can determine what this tool does and what it is not without inspecting other definitions.

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

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

The description gives clear decision criteria for the primary fork: use auto_send=true for an immediate send vs draft=true/auto_send=false to defer to a human, and explicitly routes to siblings for follow-up ('poll get_envelope_status for progress', 'call send_draft'). It also states the auth prerequisite. It does not enumerate when-not-to-use cases for other siblings (e.g., void_envelope, update_draft), but the main alternative paths are clearly signaled.

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

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

Beyond the annotations, the description discloses that `fields` is a whole-list replace, that the operation only applies to unsent drafts, that no credits or invites are involved, and that a Bearer token is required. This is exactly the kind of behavioral detail an agent needs beyond readOnly/idempotent/destructive hints.

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 terse sentences deliver scope, field semantics, exclusions, and auth requirements with no filler. The most important information is front-loaded.

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

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

Given the output schema exists and annotations cover idempotency and read-only behavior, the description provides all necessary operational context: when it is valid, what fields look like, replacement semantics, exclusions, and auth. Nothing critical is missing.

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

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

Schema description coverage is 0%, but the description compensates by detailing the expected `fields` item shape: `{type, party, name?, required, position: {page_number, x, y, width, height}}`. It also clarifies that `fields` is a whole-list replace. The `document_id` parameter is not elaborated, but its meaning is inferable from the draft context.

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

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

The description opens with 'Replace the fields on an unsent Draft,' which clearly identifies the verb, resource, and scope. It also distinguishes itself from siblings by explicitly stating 'No credit debit, no invites,' so an agent knows this is not a billing or invitation operation.

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

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

The description says this applies to an 'unsent Draft' and excludes credit/invite operations, giving useful context for when to use it. It does not explicitly name an alternative like send_draft for sending, but the boundary is clear enough from the wording.

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

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

Beyond the annotations (destructiveHint, idempotentHint), the description details concrete behaviors: signing links stop immediately, non-signers are emailed, and the send credit is returned only if nobody opened the envelope. This adds valuable context about side effects and conditions, fully leveraging the opportunity to disclose behavior.

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

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

The description is three short sentences, front-loading the purpose first, then adding essential side effects. No waste, no redundancy, and every sentence contributes to understanding.

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 core purpose and side effects effectively, and since an output schema exists, return values are covered elsewhere. However, it omits any guidance on the reason parameter and does not clarify whether the envelope document itself remains accessible. Given the tool's destructive nature, this is a minor but noticeable gap.

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

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

With schema description coverage at 0%, the description must explain the parameters but does not mention document_id or reason at all. It provides zero insight into what these parameters represent or how to use them, leaving the agent to infer from names alone. This is a major gap.

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

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

The description clearly states 'Void a sent envelope so it can no longer be signed' — a specific verb, resource, and outcome that distinguishes it from siblings like send_envelope and get_envelope_status. The purpose is unambiguous and actionable.

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 specifies the condition 'sent envelope', indicating it applies to already-sent envelopes, which provides clear context for when to use it. However, it does not explicitly contrast with alternatives or mention when not to use it, so it falls short of the highest tier.

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