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

Annotations already indicate readOnly=false, idempotent=false, and destructive=false, so the safety profile is established. The description adds useful context about the schema format and advises verification via rendering, but does not disclose behaviors like duplicate creation or response shape. This is acceptable but not exceptional given the annotation coverage.

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, all purposeful: the first states the action and input, the second explains the non-obvious schema domain, and the third gives a concrete next step. No filler or redundant restatement of the tool name or schema properties.

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 tool has two required parameters, a complex nested schema, and no output schema. The description covers the schema format, how to learn it, and a post-creation verification step. It omits what the create response returns, but the workflow guidance is sufficient for an agent to invoke the tool and verify success via rendering.

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 baseline is 3. The description adds real value for the schema parameter by explaining that it is DocMake's rich-text tree format with typed variable nodes, conditionals, and loops, and points to a concrete learning method via get_template. This goes beyond the generic schema description in the input 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 opens with a specific verb and resource: 'Create a new DocMake template from a document schema JSON.' This clearly distinguishes creation from the sibling tools like list_templates, get_template, render_document, and import_docx. No ambiguity about what the tool does.

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 workflow context: learn the schema format via get_template with include_schema:true, and render a test document after creating to verify layout. It does not explicitly name alternatives like import_docx or state when not to use this tool, but the intended usage is clear enough to guide an agent.

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 read-only, idempotent, and non-destructive behavior. The description adds value beyond this by explaining the return shape (dotted keys, per-item subfields) and warning that `include_schema` can produce a large response. It does not mention failure behavior, but the annotations carry the safety profile.

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, each earning its place: the first defines what is returned, the second states when to call the tool, and the third explains a parameter caveat. It is front-loaded and contains no filler or repetition.

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 tool with no output schema, the description sufficiently explains what the agent will receive and when to call it. The annotations cover safety, the schema covers parameter details, and the description covers the shape and caveats of the output. 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?

Schema description coverage is 100%, so both parameters are already documented. The description adds meaningful context for `include_schema` by stating it returns raw document schema JSON, may be large, and is useful as a starting point for `create_template`. This goes beyond the schema's basic default and type 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 opens with a specific verb and object: 'Get a template's metadata and its field tree'. It then differentiates itself by tying the field tree to the `data` payload for `render_document` and mentioning `include_schema` as a starting point for `create_template`, so it is clearly distinct from list_templates and render_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 when-to-use guidance: 'Call this before rendering so you know exactly which data to supply.' It also provides a conditional for `include_schema` ('only if you need the raw document schema JSON'). It does not explicitly name alternatives or exclusions for the main tool, 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 indicate a read-only, idempotent, non-destructive operation. The description adds useful context about the data returned (plan, usage vs. limit, template count, API rate limits) and the quota-error scenario, going slightly beyond the 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?

Two tight sentences: the first lists what the tool returns, the second adds a practical use-case. No filler, no repetition of schema details, 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?

For a zero-parameter, read-only tool with rich annotations, the description fully covers what it does and when to call it. The lack of an output schema is not a gap because the description enumerates the key outputs.

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 is empty. According to the rubric, 0 params earns a baseline of 4; the description correctly focuses on output and usage rather than parameters.

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 names the exact resources: workspace plan, renders used vs. limit, template count, and API rate limits. It is clearly distinct from sibling tools like list_templates or render_document, which concern template management and rendering rather than usage/quota information.

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 includes an explicit trigger: 'Check this if renders start failing with quota errors.' This gives clear context for when to use the tool. However, it does not explicitly mention alternatives or when not to use it, though none of the siblings serve a similar purpose.

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 signal that this is a mutating, non-idempotent operation, and the description adds useful behavioral details: the document structure is converted into an editable template, and the file size is capped at 10 MB. It doesn't disclose the return value, but the safety-relevant behavior is already covered by annotations and the conversion behavior is explained.

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 with no filler: purpose first, then conversion behavior and follow-up options, then the size constraint. Every sentence contributes information an agent needs.

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 import tool with no output schema, the description covers the main behavior, size limit, and how to inspect the resulting template. It does not state what the tool returns (e.g., template ID), but the get_template pointer mitigates that 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?

Schema coverage is 100%, with both 'file_path' and 'name' documented in the input schema, so the description does not need to repeat parameter meanings. It adds only the global 10 MB size cap, which is relevant but not parameter-specific.

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 ('Import'), a specific resource ('local .docx file'), and a precise outcome ('new DocMake template'), and it clarifies the conversion of document structure into an editable template. This scope makes it distinguishable from siblings like create_template, which does not involve importing an existing DOCX.

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 clearly indicates the intended context: use this tool when you have a local .docx file to turn into a template. It even directs follow-up actions (adding variables or inspecting with get_template), though it does not explicitly state when not to use it or contrast it with create_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?

Annotations already cover readOnlyHint, idempotentHint, and destructiveHint, and the description aligns with them by framing the operation as a list. It adds valuable behavior details beyond annotations: exact return fields, search-by-name support, and pagination. There is no contradiction and no hidden side effects to disclose for a read-only listing tool.

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 each earn their place: purpose, return fields, usage guidance, and query capabilities. The most important information is front-loaded and there is no filler or redundancy.

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

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

For a read-only list operation with zero required parameters, the description is complete: it explains the return fields, names the sibling tools that need a template_id, and mentions search/pagination. Annotations cover safety and idempotency, and the schema covers parameters, so no output schema is needed for this 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?

Schema description coverage is 100% and each parameter already has a clear description. The description's mention of 'search by name and pagination' reinforces the schema but does not add meaning beyond what page, search, and per_page already document. The schema carries the semantic load here.

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 and resource: 'List the DocMake templates in the connected workspace.' It also states what is returned (id, name, variable count, timestamps), which clearly distinguishes it from siblings like get_template, create_template, and render_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 explicit guidance: 'Use this first when you need a template_id for get_template or render_document.' This directly tells the agent when to call this tool and how it fits with the related siblings.

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 discloses several important behaviors not fully captured by annotations: the file is saved locally, the return value is an absolute path, renders fail on missing variables with a list of missing keys, and strict:false uses fallback text. This is rich behavioral context beyond the minimal readOnly/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?

The description is compact, front-loaded with the core action and return value, then layered with the most important behavioral caveats. Every sentence adds value; there is no redundant repetition of schema details.

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 no output schema, the description covers the essential return contract (absolute path), side effects, prerequisite template lookup, and strict-mode failure behavior. Combined with the complete input schema, the agent has enough information to select and call the tool correctly.

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

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

The input schema already provides 100% parameter coverage, so the baseline is 3. The description adds meaningful semantics for data ('keys must match the template's fields') and strict ('fails and lists the missing keys' vs 'render anyway using fallback text'). This raises it above baseline, though not every parameter needs extra explanation.

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-resource pair: 'Render a DocMake template to PDF or DOCX with the given data and save the file locally.' It is clearly distinct from sibling tools like list_templates or get_template, and the mention of get_template further clarifies the rendering use case.

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

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

The description explicitly tells the agent when to invoke a sibling: 'call get_template first if you are not sure.' It also gives conditional behavior guidance for strict mode, explaining when to use strict:false to render with fallback text. This is concrete, actionable routing guidance.

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