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

With no annotations provided, the description carries the full burden. It discloses several important behaviors: returns a signing URL, can e-mail signers, requires exactly one of content/document, and notes that links go out once the contract is ready for signing. It also mentions the 5-sends-per-signer limit and the 3 MB PDF limit. It doesn't mention whether creation is reversible or what happens to drafts, but it covers the most critical behaviors.

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 states the core purpose and output in the first sentence, then the key constraint (exactly one of content/document) in the second. It doesn't waste words, though it could arguably be slightly more structured. The schema carries the detailed parameter semantics, so the description doesn't need to be longer.

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 9 parameters, nested objects, and no output schema, the description does a good job of covering the essential context: what it creates, what it returns, the two input modes, and the signer e-mail behavior. It doesn't describe the return format in detail (e.g., JSON structure of the signing URL), but since there's no output schema, a bit more detail on the response shape could help. Still, the description is largely complete for an agent to decide when and how 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?

Schema description coverage is 100%, so the schema already documents all parameters. The description adds value by clarifying the relationship between `content` and `document` (exactly one), and by explaining the signers behavior (shared signUrl vs. e-mailed links). It doesn't repeat every parameter detail, which is appropriate given the schema's thoroughness.

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 ('Create'), a resource ('a new contract for signing'), and the two input modes (HTML content or PDF file). It also names the key output (a signing URL) and the optional e-mail behavior, which distinguishes it from sibling tools like update_contract, list_contracts, get_contract, and delete_contract.

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 context: use this to create a contract for signing, and it explicitly says to give exactly one of `content` or `document`. It also mentions that attachments require calling list_attachment_types first, which is a useful prerequisite. However, it doesn't explicitly say when to prefer update_contract or list_contracts, though the verb 'create' makes that fairly obvious.

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 provided, the description bears full responsibility for disclosing behavior. It does disclose a critical constraint: signed contracts cannot be deleted, which informs the agent of a likely error condition. However, it does not state whether deletion is permanent, irreversible, or has cascading effects, leaving significant behavioral ambiguity for a destructive operation.

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 core action, and includes a critical constraint in a single additional sentence. There is no redundant wording, and the structure is optimal for quick parsing.

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 delete tool with one parameter and no output schema, the description covers the core operation and a key constraint. However, it omits details such as whether deletion is permanent, what happens if the contract is signed (error vs. no-op), and any permission requirements. Given the absence of annotations, these omissions leave the tool slightly under-specified for an agent to fully anticipate 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?

The schema description for the sole parameter 'id' is clear ('Contract ID or token'), and schema coverage is 100%, so the schema carries the parameter documentation. The description adds no additional semantic detail about the parameter, matching the baseline expectation of 3.

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

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

The description states a specific verb and resource ('Delete a contract') and is distinct from all siblings (create, update, list, get, list_attachment_types). It does not restate the name and clearly identifies the operation. The added note about signed contracts also enriches purpose by clarifying scope.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention that update_contract should be used for modifications or that get_contract/list_contracts are for retrieval. The usage context is implied by the name and sibling list but not stated, leaving the agent to infer selection criteria.

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 provided, the description carries the full burden of behavioral disclosure. It states 'Get details' which implies a read-only operation, but does not explicitly confirm that it has no side effects, nor does it mention any required permissions, error behaviors, or response format. The description adds minimal behavioral context beyond the verb, leaving an agent uncertain about operational constraints.

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, concise sentence with no wasted words. It front-loads the core action ('Get details of a specific contract') and then provides the identification method. Every word serves a purpose, achieving high efficiency and 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?

Given the tool's low complexity (one required parameter, no nested objects, no output schema), the description covers the essential information: what it does and how to specify the target. However, because there is no output schema, the description could have mentioned what kind of details are returned or that it returns a full contract object. This is a minor gap but not critical for a simple read operation.

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

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

Schema description coverage is 100% and the schema already states 'Contract ID or token' for the id parameter. The description repeats this same information ('by ID or token') without adding new meaning, such as format, examples, or the relationship between the two identifier types. Thus, the description adds no extra semantic value over the schema, aligning with the baseline of 3.

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

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

The description clearly states a specific verb ('Get details') and resource ('a specific contract'), and distinguishes itself from siblings like list_contracts by targeting a single contract. The addition of 'by ID or token' further clarifies how the contract is identified, leaving no ambiguity about the tool's purpose.

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

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

The description implies usage context: use this when you need details for a single contract and have its ID or token. However, it does not explicitly mention when not to use it, such as preferring list_contracts when wanting multiple contracts, or create/update/delete for modifications. This is a clear context without explicit exclusions or alternatives.

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

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

With no annotations, the description carries the disclosure burden. It makes clear the tool is a read-only listing operation, describes the returned content (forms plus required fields), and warns about downstream failure modes. It does not mention output format or filtering behavior, but 'List' plus the stated content is reasonably transparent.

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 focused sentences: the first states the resource and return value, the second gives usage timing and rationale. Every sentence earns its place and the critical purpose 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 one-parameter read-only list tool, the description covers purpose, when to use it, and why the returned fields matter. It does not describe the exact return shape, but the description already states what is listed and no output schema exists to shift that burden.

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

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

Schema coverage is 100% and the single optional country parameter already has a clear description. The tool description adds no extra meaning about the country filter, so the score stays at the baseline for full schema coverage.

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 lists attachment forms for contracts and the fields each requires. This distinguishes it from siblings like list_contracts, which lists contracts themselves, and create_contract, which is the downstream consumer.

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

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

It explicitly says to use this tool before create_contract when the contract needs an attachment, and explains why: missing required fields are rejected and wrong fields become blank on signed documents. This is clear, actionable 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?

No annotations are present, so the description carries the burden of disclosing the operation's behavior. 'List' signals a read-only, non-destructive operation, and the status filter is mentioned. It does not disclose response format, pagination behavior, or ordering, but the tool is simple and the schema covers the limit and status parameters. The description adds only marginal behavioral context beyond the verb.

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 only two short sentences with no filler or repetition. The core action 'List all contracts' is front-loaded, and the filter note adds useful capability information. 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 parameter-light read-only tool with no output schema, the description and schema together deliver the essential details: the action, the resource, and the only two optional inputs with their constraints. 'List' clearly indicates a collection return, and there are no nested objects or annotations to complicate the call. The lack of explicit sibling guidance and response-shape information is a minor gap, but the definition is nearly complete for its complexity.

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

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

Schema description coverage is 100%, so both 'limit' and 'status' are fully documented in the input schema with types, defaults, and enum values. The description's 'Can filter by status' restates what the schema already says without adding meaning. The baseline of 3 is appropriate because the schema does the descriptive heavy lifting.

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, 'List,' and resource, 'contracts,' which clearly distinguishes the all-contracts listing endpoint from the singular get_contract and the mutation siblings. It also notes the optional status filter. However, it doesn't explicitly contrast with get_contract, so it stops short of fully differentiating among siblings.

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

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

The phrase 'List all contracts' implies this tool is for retrieving a collection rather than a single contract, which gives some usage context. There is no explicit when-to-use guidance or mention of alternatives like get_contract for a single contract. The usage is implied rather than stated, earning a 3.

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 provided, the description carries the full burden of behavioral disclosure. It clearly states side effects: resending to the same address, replacement invalidating the old link, and the response containing link statuses. This goes well beyond a generic 'updates a contract' statement.

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 sentences: first the core action, then critical behavior, then response format. Every sentence carries necessary information with no filler or repetition. This is an excellent, front-loaded 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?

Given full schema coverage and no output schema, the description sufficiently covers the main operational aspects: what actions apply, link resend/replace behavior, and response statuses. It omits only minor details like error handling or authentication prerequisites, which are not required for the tool's complexity level.

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%, giving a baseline of 3. The description adds extra meaning for the signers parameter by explaining email replacement/resend behavior and the finalize flag's trigger effect, which the schema itself does not fully express. This meaningful supplementation justifies above baseline.

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 phrase ('Rename, retag or finalize a draft, and send or resend signing links') identifying both the resource and the set of distinct operations. This clearly distinguishes update_contract from siblings like create_contract, get_contract, and delete_contract.

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 strongly implies when to use this tool: when modifying an existing contract's title/tags, finalizing a draft, or managing signer links. It also explains the resend-vs-replace behavior, guiding the caller. However, it does not explicitly name alternatives or state 'use create_contract for new contracts,' 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.