PDFOven

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

Annotations establish the write/non-destructive/non-idempotent profile, so the bar is lower, and the description adds real value on top: a per-plan quota (Free 3) and the fact that exceeding it returns a tool error rather than silently succeeding. It also discloses that the response carries an id. Auth requirements and whether re-creating the same name collides are not covered.

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 sentences, all load-bearing: what it does and returns, the quota boundary, then the downstream render path. The most actionable fact (id is returned) is front-loaded and nothing is repeated from the schema.

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 write tool with nested page_options and no output schema, the description covers the outcome (returns an id), the failure boundary (plan cap), and the follow-on workflow, which is what an agent needs to sequence calls. Remaining gaps, such as permission requirements and name-collision behavior, are minor rather than blocking.

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%, with css, engine, content format, sample_data, and page_options all documented in the schema, so the baseline of 3 applies. The description only gestures at data via "template_id plus data" and adds no syntax or constraint detail beyond what the schema already states.

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?

Specific verb+resource ("Save a new reusable template") with the concrete side effect of returning an id. The word "new" plus the account-level scope clearly separates it from update_template, get_template, and list_templates in the sibling set. An agent can select this tool 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?

States the creation context and the natural follow-on path ("Render it later with render_pdf or render_image and template_id plus data"), which is genuine routing guidance toward siblings. It does not state when to use update_template instead or any prerequisites such as required permissions, so it stops short of explicit when-not 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered by structured data. The description adds real behavioral context beyond that: the deletion cannot be undone and references using the template_id will subsequently fail, which annotations cannot express.

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 sentences with zero filler; the destructive nature and irreversibility are front-loaded and the confirmation requirement is placed last as an action step.

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 mutation with rich annotations and no output schema, the description covers everything an agent needs: permanence, downstream breakage, and a user-confirmation requirement.

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 template_id parameter already documents its format and origin (from list_templates). The description adds no parameter-level meaning, 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 and resource ('Permanently delete a saved template') with the permanence qualifier adding scope. It is clearly distinguishable from create/get/list/update/render siblings by verb alone, though it does not explicitly name an alternative.

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?

'Confirm with the user first' gives an actionable precondition for invoking the tool. However, it offers no routing guidance — e.g. that update_template should be used if the caller only wants to modify rather than remove 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered. The description adds a genuinely useful behavioral fact not in the annotations: 'Does not use render quota', which is the key operational difference from the render_image/render_pdf siblings.

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 sentences, front-loaded with the core action, followed by the workflow hint and the quota note. Every sentence earns its place with no filler.

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

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

There is no output schema, so the description carries the burden of describing returns and does so by naming the four payload fields. Combined with the workflow and quota guidance, an agent has everything needed to call and use the result.

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 template_id is documented in the schema with an example from list_templates. The description's enumeration refers to return fields, not the input parameter, so it adds little parameter meaning beyond the schema. 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?

Specific verb ('Fetch one saved template in full') plus enumerated returned fields (content, css, sample_data, page_options) make the resource and scope unambiguous. An agent can distinguish it from list_templates and the render_* siblings without opening any 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?

Explicitly names when to use it ('before update_template to see the current body'), which routes the agent correctly within an edit workflow. It stops short of stating when the tool is unnecessary (e.g., when only metadata is needed), so it is clear guidance but not a full when/when-not matrix.

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 readOnly, idempotent, non-destructive and non-open-world, so the safety profile is covered. The description adds useful behavioral facts beyond that: results are ordered newest first and the call 'Does not use render quota', which matters for cost-aware agents. It stops short of any pagination or result-size behavior, so not a full 5.

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 compact sentences with the core promise (what is listed, in what order, with which fields) front-loaded, followed by the usage pointer and the quota note. Nothing is redundant.

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 present, the description compensates by enumerating the returned fields (id, name, engine, sample_data) and the ordering, which is exactly what an agent needs to parse results. For a zero-parameter read tool with full annotation coverage, nothing material is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description's mention of template_id is about output consumption rather than an input, and the empty schema needs no further elaboration.

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?

Names a specific verb and resource (list every template in the PDFOven account) plus the ordering (newest first) and the exact fields returned. It also distinguishes itself from siblings by directing the agent to render_pdf/render_image or get_template for consuming a single id.

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?

Explicitly describes the workflow: take an id from this listing and feed it into render_pdf/render_image (as template_id) or get_template. That routes the agent to the right sibling for the next step without ambiguity.

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 disclose openWorldHint=true (URL capture), idempotentHint=true and destructiveHint=false, and the description adds three non-obvious behaviors the annotations do not carry: monthly quota consumption per successful call, nothing is persisted, and the image is returned inline. That is real added value, though error/failure behavior (e.g. no source supplied) is left unstated.

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, no filler, with the source-selection constraint front-loaded and cost/persistence notes compressed into a single trailing clause. Every clause 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 0-required-parameter, nested-object tool with no output schema, the description covers the essentials: how the image comes back (inline) and the one-source rule that prevents an invalid empty call. It omits failure modes and quota-exhaustion behavior, a minor gap given the rich schema.

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 88%, so the schema carries the per-parameter burden and a baseline 3 applies. The description still adds semantics beyond the schema by expressing mutual exclusivity ('exactly one source') and the pairing relationships (template/template_id each filled with data), which the flat schema does not convey.

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 (render) and resource (PNG image) plus concrete output exemplars (social card, certificate, chart). It names the exact set of accepted sources, which immediately separates it from render_pdf and the template CRUD 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 'from exactly one source' constraint and the enumerated alternatives (html, markdown, url, template+data, template_id+data) tell the agent precisely which input path to pick. It stops short of explicitly routing the agent to render_pdf for PDF output or naming when-not-to-use conditions, so it is clear context without 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?

Goes well beyond the annotations by disclosing quota consumption per successful call, that nothing is stored, and that over-quota or invalid input surfaces a tool error with an explanation. These are exactly the operational facts an agent needs before invoking, and they do not conflict with readOnlyHint=false / idempotentHint=true.

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 tight sentences: what it renders, what it returns, and the operational caveats. Zero filler and the source constraint is front-loaded before the quota detail.

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 eight parameters, nested options, and no output schema, the description still covers return format (base64 embedded resource), input mode rules, and failure behavior. Nothing an agent needs to call it correctly 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 coverage is 88%, so parameter-level descriptions largely come from the schema. The description still adds the critical mutual-exclusivity rule across the five source parameters, which the schema does not encode, making it more than a restatement.

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 (Render) and resource (PDF) and immediately constrains the input modes, which cleanly distinguishes it from render_image and the template CRUD siblings. An agent knows exactly what this tool produces.

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 makes the key usage rule explicit: exactly one source among html, markdown, url, template(+data) or template_id(+data). It does not, however, say when to prefer render_pdf over the sibling render_image, so context selection is left 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?

Annotations already declare destructive=false, idempotent=true and readOnly=false, so the bar is lower, and the description adds real value beyond them: it discloses partial-update semantics ("only the fields you pass are replaced") and the immediacy of the effect on future renders. It does not mention auth requirements or error behavior for an invalid template_id, so it falls short of 5.

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 sentences, each earning its place: identity, partial-update rule, and effect timing. The most decision-relevant constraint is front-loaded after the purpose statement.

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 7-parameter mutation tool whose schema is 100% documented and whose annotations carry the safety profile, the description covers identity, update semantics, and effect timing. Minor gaps remain: whether fields can be cleared/nulled and what happens on an unknown template_id, but no output schema exists and none is strictly required.

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 nested page_options object is fully documented in the schema, so the schema carries parameter meaning; the description adds no field-level detail. 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 ("Change a saved template") that clearly identifies this as a mutation of an existing template, distinguish-able from create/delete/get/list by the verb alone. It stops short of explicitly naming a sibling or the partial-update style beyond the following sentence.

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 explicit when-to-use / when-not guidance or prerequisites (e.g. "use create_template for new templates", "get the id from list_templates first"). Usage is only implied by the verb, matching the calibration's 2 for a comparable mutation tool with no routing guidance.

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