Dropbox Sign MCP by usefulapi

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

The destructiveHint annotation already flags the mutation, but the description adds genuine value by spelling out the concrete consequence: signers can no longer sign. It stops short of covering idempotency, auth requirements, or reversibility, so it is strong but not exhaustive.

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

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

Three terse sentences: purpose first, destructive consequence second, endpoint third. Nothing is wasted and the most decision-relevant 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 single-parameter destructive tool with no output schema and full annotation coverage of destructiveness, the description supplies everything needed: what it does, the condition under which it applies, and the consequence. Return values are unnecessary here.

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

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

There is only one parameter and schema description coverage is 100%, with the schema itself stating it is 'the id of the incomplete signature request to cancel.' The description adds no format, source, or id-syntax detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (cancels) and resource (signature request) and narrows the scope to 'incomplete' requests, which no sibling tool touches. An agent can immediately tell this is the terminal/cancel action versus get/list/remind/send 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 precondition 'incomplete signature request' acts as clear usage context, and 'Destructive — signers can no longer sign' warns the agent about consequences. It does not, however, name alternatives (e.g., remind_signature_request for nudging instead of canceling) or state what happens if the request is already 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?

readOnlyHint=true already tells the agent this is a safe read, so the description's main addition is the fact that it reflects the API-key owner's account rather than a team. It adds little else: no rate-limit, auth-scope, or horizon details beyond the endpoint reference.

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

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

A single front-loaded sentence naming resource and returned data, followed by a compact endpoint reference. Nothing is padded or 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?

With no parameters and no output schema, the description compensates by enumerating the key response fields (id, email, quotas, plan), which is enough for an agent to know what it gets back. It stops short of describing quotas' shape or plan details, but is adequate for a zero-argument read.

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

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

The tool takes zero parameters, so the baseline is 4. The description's mention of the returned fields (id, email, quotas, plan) is slightly relevant context but there are no parameters to disambiguate.

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

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

States a specific verb and resource ('Get info about the API-key owner's Dropbox Sign account') and even lists the returned fields, which is more than a tautology. It differentiates from dropbox_sign_get_team by scoping to the API-key owner's own account, though it never names the sibling explicitly.

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

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

Usage is only implied: an agent can infer this is the tool for inspecting the current account, but there is no statement of when to prefer it over get_team or other siblings, and no prerequisites or exclusions are given.

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 annotation already tells the agent this is a safe, non-mutating read, so the description's main added value is mapping to the underlying GET endpoint. It discloses nothing about auth requirements, error behavior for an invalid or expired id, or rate limits, which would be genuinely useful context here.

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, front-loaded sentences with the core purpose first. The second sentence (raw API path) is mildly useful for mapping but is arguably redundant filler for an agent that only needs the semantic description.

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

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

For a one-parameter read tool with no output schema, the description covers what is retrieved and hints at the returned content ('status and details'). It is close to complete, though absent return-shape or failure-mode hints it falls short of fully self-sufficient.

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

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

Schema description coverage is 100% and the single parameter is fully documented in the schema. The description's 'by id' merely echoes the parameter's purpose without adding format, sourcing, or constraint details, so the baseline 3 applies.

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

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

States a specific verb (Get) and resource (signature request) with an explicit scope qualifier ('a single ... by id'), which separates it from the sibling dropbox_sign_list_signature_requests. An agent can tell what the tool returns (status and details) without opening the schema.

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

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

The phrase 'single signature request by id' implies the use case (look up one known request), but the description never states when to prefer this over list_signature_requests or what to do if the id is unknown. Usage is inferable rather than explicitly guided.

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 readOnlyHint=true, so the safety profile is covered. The description usefully adds that the returned URL is 'temporary,' which is behavior beyond the annotations, but it omits the expiry window, any precondition that the request be completed/signed, and what the response payload contains.

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

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

Two sentences, front-loaded with the action and payoff, with the endpoint appended as a compact API mapping. No filler, though the raw endpoint path adds little for an agent that already has a callable tool.

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 tool with annotations and no output schema, the description is nearly sufficient: it states the return type (a temporary URL) and its purpose. Minor gaps around URL expiry and preconditions keep it from being 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 coverage is 100% and the single parameter is fully documented in the schema itself. The description adds no syntax, format, or constraint detail for signature_request_id beyond what the schema already states, so the baseline 3 applies.

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

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

The description names a specific verb and resource: 'Get a temporary URL to download the signed document(s) for a signature request,' which clearly distinguishes it from metadata-oriented siblings like get_signature_request. It does not explicitly name which sibling to use instead, but the action is unambiguous.

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

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

The phrase 'to download the signed document(s)' implies the intended use case, but there is no explicit when-to-use versus when-not guidance and no comparison to alternatives such as get_signature_request (metadata) or list_signature_requests. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered by structured data. The description adds scope information (members plus invited members are returned) beyond the annotations, but says nothing about auth requirements or team-size/pagination behavior for what can be a large collection.

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, front-loaded with the payload description. The trailing "API: GET /team" is mildly redundant for an agent but costs little.

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

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

A simple, zero-parameter read tool with no output schema; the description sketches the returned content (team, members, invited members) and annotations cover safety. It is essentially complete, lacking only return-shape or volume details.

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

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

The tool takes no parameters and schema coverage is 100%, so there is nothing for the description to clarify; baseline is 4 for a zero-parameter tool.

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

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

States a specific verb and resource (get the caller's team) and disambiguates content by noting it includes members and invited members. It does not name the closest sibling (dropbox_sign_get_account) to distinguish account vs team, but the resource is unambiguous.

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

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

Retrieval of "the caller's team" implies its own context, and the description names no when-to-use conditions, prerequisites, or alternatives such as dropbox_sign_get_account. Usage is inferable but not stated.

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

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

The readOnlyHint annotation already tells the agent this is a safe non-mutating read, so the description only needs to add context. It adds the underlying API route (GET /template/{template_id}) and the shape of the response, but says nothing about auth requirements, rate limits, or error behavior for missing ids.

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

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

Two tight sentences, with the functional purpose front-loaded and the API route appended as supporting detail. Nothing is padded, though the raw endpoint is marginally redundant with 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?

For a one-parameter, read-only fetch with no output schema, the description covers the essential facts: what identity key is required and what data comes back. Remaining gaps (error handling on unknown ids) are minor for a tool this simple.

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

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

Schema coverage is 100% and the single parameter's description ('The id of the template to retrieve') is already complete. The description's 'by id' adds no format, source, or lookup guidance beyond what the schema states, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Get a single template') and enumerates the payload ('fields, roles, and metadata'), so the agent knows exactly what the call returns. The word 'single' implicitly contrasts with the sibling list_templates, but no sibling is named explicitly, which keeps this short of a 5.

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

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

Usage is only implied: the tool takes a template_id and fetches one template, which suggests it is the detail-view counterpart to dropbox_sign_list_templates. There is no explicit statement of when to prefer this over listing templates or sending with a template.

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 annotation already covers safety, and the description adds two genuinely useful behavioral facts beyond it: results are sorted 'newest first' and the endpoint is paginated, plus the raw API path. It stops short of describing pagination limits or auth requirements, which the schema partially covers.

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, zero filler, with the core purpose, ordering, and pagination front-loaded before the API note. Every sentence 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 read-only paginated list tool with fully documented parameters and an annotation covering safety, this supplies purpose, ordering, and pagination. Since no output schema exists, it could say more about the returned shape, but nothing essential to correct invocation is missing.

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

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

Schema description coverage is 100%, so all four parameters (page, query, page_size, account_id) are already documented in the schema. The description adds no syntax or format detail beyond that, making the baseline 3 appropriate.

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

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

States a specific verb (List) and resource (signature requests) with scope ('the account can access') and even names the backing API endpoint. It implicitly contrasts with the singular get_signature_request sibling but never says so explicitly, keeping it just short of a 5.

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

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

Usage is implied by the phrase 'the account can access' and the paginated framing, so an agent can infer this is the enumeration entry point. However, there is no explicit when-to-use versus get_signature_request / search-style alternatives, and no mention of when to pass account_id.

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, so the safety profile is covered. The description adds only 'Paginated', which duplicates what page/page_size in the schema already communicate, and an API endpoint reference. No return-shape or ordering behavior beyond 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?

Three short front-loaded fragments with no filler: purpose, pagination behavior, and API mapping. Nothing is redundant or buried.

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, four-optional-parameter list tool with full schema coverage and no output schema, the description covers what is needed to invoke it. It does not address what a returned template contains or how to page through results, but the annotations and schema carry most of 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 description coverage is 100%: page, query, page_size, and account_id are each documented in the schema, with defaults and max values included. The description adds no parameter meaning beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource ('List reusable templates the account can access') with a scope qualifier, which is enough to separate it from sibling dropbox_sign_get_template. It stops short of naming that sibling explicitly, so differentiation is inferred from the name rather than stated.

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

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

There is no when-to-use guidance, no mention of when to prefer get_template over this list, and no note about filtering conditions. The only context given is 'Paginated' and the underlying API path, which does not tell the agent when this tool is the right 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 declare destructiveHint=true, and the description does not contradict that. It adds useful context that the action sends an email to a signer, requires a pending request, and uses a specific API endpoint, but it does not explain what the destructive hint means operationally or describe side effects beyond the email.

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 tightly written sentences with the core action front-loaded and the API endpoint as supporting detail. Every sentence earns its place and there is no wasted language.

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

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

For a two-parameter mutation tool with full schema coverage and no output schema, the description covers the essential action, target, and endpoint. It could go slightly further in clarifying the destructive/irreversible nature hinted by annotations, but it is otherwise complete 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 coverage is 100%, so the schema already documents both required parameters fully. The description embeds signature_request_id in the endpoint path but adds no additional meaning, constraints, or format guidance beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource ('Sends a reminder email') and scopes it to a signer on a pending signature request. It is immediately distinguishable from siblings like cancel, get, list, and send_with_template without needing to inspect the schema.

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

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

The phrase 'for a pending signature request' implies the context in which this tool applies, but there is no explicit when-to-use guidance or alternative comparison. An agent can infer usage from the pending-request qualifier, yet no exclusions or sibling routing are provided.

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 declare destructiveHint=true; the description goes beyond that by disclosing the default test_mode behavior (no real emails) and the consequence of test_mode=false (a REAL, legally-binding request). This is meaningful side-effect context an agent would not get from the schema alone. It stops short of describing return values or rate-limit 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?

Two functional sentences with the high-stakes test_mode caveat front-loaded, followed by the endpoint. Nothing is padded and the most important warning is not buried.

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

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

With no output schema, the description need not explain returns, and 100% schema coverage handles parameters. It covers the critical trap (test_mode default) that governs whether a real legal request is sent. It could note that the returned signature_request id feeds siblings like remind/cancel, but that is a minor omission for this call-site.

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 every parameter already carries inline documentation and the baseline is 3. The description restates template_ids, signers and the test_mode semantics but adds no format or syntax detail beyond the schema.

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

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

States a specific verb and resource ('Sends a signature request built from template(s) to the given signers'), and names the templates and signers involved. It is immediately distinguishable from read siblings like get_signature_request and list_templates, and from the mutation sibling remind_signature_request.

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

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

Gives clear context for the key decision (test vs. real send) by stating test_mode defaults to true and must be set false for a real request. It does not, however, mention exclusions or route the agent to alternatives such as remind_signature_request or cancel_signature_request, which is a mild gap.

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