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

Since no annotations are provided, the description carries the burden of disclosing behavior. It clearly states that deletion is permanent and also deletes the generated PDF, which is a critical side effect. This is exactly the kind of behavioral disclosure an agent needs for a destructive operation, even though it lacks mention of ownership or permission requirements.

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

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

The description is a single, well-structured sentence that front-loads the action ('delete') and clearly states the scope, including the generated PDF. There is no wasted wording.

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, the description covers the essential: the action and its impact. However, it could add a note on how to confirm deletion (e.g., via response) or whether deletion is reversible, but given the simplicity, it is nearly 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?

The schema provides a description for document_id ('The ID of the document to delete'), and coverage is 100%, so the schema fully documents the parameter. The description does not add extra meaning, such as where to find the ID or any format constraints, 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?

The description specifies a clear verb ('delete') and a resource ('document and its generated PDF'), which distinguishes it from non-destructive siblings like get_document_status. However, it does not differentiate from potential delete operations on other resources (e.g., snippets), but in this sibling context, it 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 description gives no guidance on when to use this tool versus alternatives, and no exclusions (e.g., 'use only if you own the document'). It implies a use case (deleting a document) but doesn't specify prerequisites or warn against deleting documents in use.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does this well by revealing that generation is asynchronous, that polling happens automatically until completion, and that the result is a download URL. It does not mention side effects like document persistence or quota impact, but the core mutation and return behavior are 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?

The description is three concise sentences with no filler. The primary purpose is front-loaded, the async behavior and return value are stated next, and the workspace option is placed last. Every sentence contributes useful information.

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 6-parameter tool with no output schema and no annotations, the description does a good job covering the return value and async workflow. It could additionally mention failure modes or how to source template_id, but the schema plus sibling tool names provide enough context for an agent to invoke it correctly.

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

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

The schema covers all 6 parameters with descriptions, so the baseline is 3. The description adds only minimal semantic value beyond the schema, such as clarifying that payload is 'provided data' and that workspace_id is optional. It does not enrich parameter understanding meaningfully, but it does not need to because the schema already documents the parameters well.

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 begins with a specific verb and resource: 'Generate a PDF document from a template with provided data.' This clearly distinguishes it from sibling tools like list_documents, delete_document, and get_document_status, which are about retrieving or managing documents rather than creating them.

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 for when to use the tool: when a PDF needs to be produced from a template. It also communicates the async polling workflow and optional workspace targeting, though it does not explicitly state exclusions or name alternatives like list_templates for finding a template_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?

With no annotations, the description must carry the behavioral burden. It states the primary action (checking status) and a conditional outcome (get URL if ready), but doesn't disclose side effects, error behavior (e.g., document not found), response format, or whether it's a read-only operation. This is minimal.

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 sentence with no waste. It front-loads the primary action and conditionally adds the secondary outcome, making it concise and easily parsed.

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 tool, the description covers the main function, but without an output schema or annotations, it leaves gaps: it doesn't explain typical status values, what happens when the document isn't ready, or the response structure. Since the tool is low in complexity, a 3 is appropriate—adequate but not robust.

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 parameter document_id is described as 'The ID of the document to check' in the schema itself. The description adds no additional semantic detail beyond that, so it meets the baseline of 3 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 checks document generation status and retrieves a download URL when ready. It uses a specific verb and resource, and the name is self-explanatory. It doesn't explicitly differentiate from siblings like generate_document, but the purpose is unambiguous enough to avoid confusion.

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 you use this to check status but gives no explicit guidance on when to choose this over generate_document or other sibling tools. There is no mention of alternatives or conditional usage, leaving the agent to infer appropriate context.

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 word 'Get' clearly implies a read-only operation, and 'current' suggests a fresh response, but no explicit disclosure of authentication requirements, rate limits, or response format is provided. Since there are no annotations, the description carries the burden, and it only partially satisfies it.

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 sentence with no filler. It front-loads the verb and resource and stays appropriately concise.

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 parameterless getter, the description is essentially complete: it names the data returned (quota and plan info) and the scope (account). It does not describe exact output fields, but no output schema exists to fill that gap. Still, the main intent and invocation are clear.

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, so the schema already covers everything. The description adds no further semantic meaning, and the baseline of 4 applies because no parameter documentation is needed.

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 action ('Get'), a clear resource ('current quota and plan information'), and the scope ('for the account'). This differentiates it from sibling tools like get_user_info or get_snippet, which target different resources.

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

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

No guidance is given on when to use this tool instead of the closely related get_user_info or the other getter/list tools. The description states what it does but provides no context for selection or exclusions.

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

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

With no annotations, the description must carry the behavioral burden. 'Get' does imply a read-only retrieval and 'Liquid code' describes the returned substance, but nothing is said about side effects, errors, permissions, or the exact response shape.

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, front-loaded sentence with zero filler. Every word contributes to the agent's understanding of what the tool returns.

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 getter, the description and schema cover the basics. However, there are no annotations and no output schema, so the description does not disclose potential errors, permissions, or the complete response format beyond saying it is Liquid code.

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 snippet_id is already documented clearly. The description adds no additional parameter semantics beyond reinforcing that the ID identifies the snippet to retrieve.

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 ('Get'), a precise resource ('a specific snippet'), and the returned content type ('Liquid code'). This clearly distinguishes it from list_snippets (...) and get_template (...).

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 'a specific snippet' implies use when retrieving one snippet by ID, and list_snippets is an obvious sibling for enumeration. However, there is no explicit guidance on when not to use it or what to use instead, leaving the routing to inference.

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 must disclose behavioral traits. The verb 'get' implies a read operation, but the description does not explicitly state that it is read-only, does not mention authentication or permission requirements, and gives no information about error behavior or rate limits. The addition of 'including HTML, CSS, and sample data' describes return content but not side effects or safety.

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, focused sentence that front-loads the core action and resource, then specifies the return content. There is zero fluff or repetition; every word contributes to the agent's 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?

Although there is no output schema, the description partially covers return values by naming HTML, CSS, and sample data. It also indirectly identifies the input (template_id) and the scope ('a specific template'). For a simple read tool with one parameter, this is largely complete, though it could mention what happens on invalid IDs or whether additional metadata is returned.

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 template_id as 'The ID of the template to retrieve'. The tool description adds no further meaning about the parameter (e.g., format, examples, or constraints). Baseline 3 is appropriate because the schema does the 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 ('Get') and resource ('detailed information about a specific template') and clarifies the content ('HTML, CSS, and sample data'). This clearly distinguishes it from sibling tools like list_templates (which would return a collection) and get_snippet (which targets a different resource type).

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 that this tool is used when you need details about one specific template (as opposed to listing templates), but it does not explicitly state when to use it over alternatives like list_templates or get_snippet, nor does it mention any exclusion criteria. The usage context 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?

No annotations are provided, so the description carries the full burden. The verb 'get' implies a read operation, but the description does not explicitly state that it is non-destructive, requires authentication, or has any side effects. It also does not mention potential response size or performance characteristics. This is a minimal disclosure that does not go beyond the verb itself.

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, front-loaded sentence that immediately states the action and resource, then enumerates what is included. There is no extraneous information, making it efficient and easy to parse.

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

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

For a simple getter with no parameters and no output schema, the description adequately communicates what the tool returns (complete user info including personal details, plan, settings). It does not mention response format or potential caveats, but given the simplicity, it is largely sufficient. It does not explicitly state that it is read-only, which would be helpful, but that falls under behavioral transparency.

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 zero parameters, so there is nothing to document. Per the rubric, with 0 parameters the baseline is 4. The description correctly makes no parameter claims, and the high schema coverage (100%) means the schema is complete. No additional semantic explanation is needed.

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 verb 'Get', the resource 'user account information', and enumerates the included details (personal details, plan, settings). This distinguishes it from siblings like get_snippet or get_quota, which target specific resources. It is specific and 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 implies usage when user account info is needed, but it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or preconditions. With siblings like get_quota and list_workspaces, an agent might infer context, but the description provides no explicit routing guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. The verb 'list' clearly signals a read-only operation, and the filtering scope is stated. However, it does not disclose behaviors like default pagination, ordering, or whether all documents are returned when no filters are provided.

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

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

A single sentence that states the action, resource, and filter options with no unnecessary words. The core function is front-loaded and 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?

The description and schema together are adequate for a simple, read-only listing operation with four optional parameters. However, there is no output schema and no mention of default behavior or alternatives, so some context is missing for an agent to make fully informed decisions.

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 input schema already documents all four parameters clearly. The description adds a concise summary of the filter options but no new semantic 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?

The description states a specific verb and resource ('List documents') and names the exact filtering dimensions (status, template, update time). This distinguishes it from sibling tools like list_templates and list_snippets, which operate on different resources.

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 the tool is for retrieving documents with optional filters, but it does not explicitly say when to use this over alternatives. No exclusions or conditions are provided, leaving the agent to infer usage.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action but doesn't mention read-only nature, whether full snippet contents or just metadata are returned, potential pagination, or auth requirements.

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

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

A single, front-loaded sentence with no filler. Every word adds meaning, and the structure is immediately scannable.

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 zero-parameter list tool, the description adequately captures the primary behavior. However, since there is no output schema, it could be improved by hinting at what the returned list contains (e.g., names, IDs, or full snippet code).

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, so there is nothing to document. The baseline of 4 applies because the description need not compensate for any missing parameter information.

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 ('List') and resource ('reusable Liquid code snippets') with a defined scope ('in the workspace'). This distinguishes it from siblings like get_snippet (singular retrieval), list_templates, and list_documents.

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

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

No guidance is given on when to use this tool instead of alternatives. For example, it doesn't mention that get_snippet should be used to fetch a single snippet's content. The agent must infer this from 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?

No annotations are provided, so the description must carry behavioral disclosure itself. It does convey that this is a read-only listing operation with optional workspace scoping. However, it does not mention return format, pagination, or error behavior, so it falls short of a higher score.

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, with the core purpose front-loaded and the optional parameter mentioned immediately after. 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?

This is a simple list tool with a single optional, fully documented parameter, so the description is mostly sufficient. The only notable omission is the return shape or contents of the listing, since no output schema is provided to cover that.

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 explains that workspace_id is optional and defaults to the current workspace. The description only restates this parameter behavior rather than adding new semantic detail.

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: 'List all PDF templates available in the workspace.' This clearly separates it from sibling tools like get_template (single template retrieval) and list_documents/list_snippets (other resource types).

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 contextual guidance by explaining the optional workspace scoping and the default behavior when workspace_id is omitted. It does not explicitly name alternative tools or exclusion conditions, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that it lists workspaces accessible with the current API key, which implies a read-only operation and a list result. However, it does not explicitly confirm read-only behavior, pagination, or any side effects. The description is not contradictory, but it is minimal.

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, clear sentence with no wasted words. It front-loads the action and resource, making it immediately scannable.

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

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

For a zero-parameter list operation with no output schema, the description is nearly complete. It names the resource and the scope (current API key). It does not explicitly describe the return format, but the verb 'list' implies an array of workspace objects, which is sufficient for an agent to invoke correctly.

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

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

The tool has zero parameters, and the input schema is empty with 100% coverage. Per the rubric, a zero-parameter tool earns a baseline of 4 because there is nothing for the description to clarify. The description correctly omits any parameter details.

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 'List' and the resource 'all PDFMonkey workspaces' with a qualifier about the current API key. It distinguishes from sibling list tools (list_templates, list_documents, list_snippets) by resource, leaving no ambiguity about what it 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 implies this tool is for retrieving workspace lists, but it does not explicitly state when to use it over the sibling list tools or provide exclusions. The use case is evident from the resource name, but there is no direct comparison to alternatives.

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