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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: asynchronous execution ('job runs asynchronously'), immediate return with batchId ('returns immediately with a batchId (HTTP 202)'), quota/plan limitations ('Supports up to 100 items per batch (plan-dependent)'), and concurrency implications ('Higher values complete faster but consume quota faster'). It doesn't mention error handling or retry behavior, but covers most critical operational aspects.

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 efficiently structured with front-loaded purpose, followed by use cases, workflow steps, and behavioral notes. Every sentence adds value: the first establishes core functionality, the second provides concrete examples, the third outlines the workflow, and the fourth covers behavioral traits and alternatives. No wasted words.

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 complex batch processing tool with 5 parameters and no annotations/output schema, the description does an excellent job covering purpose, workflow, behavioral characteristics, and alternatives. It doesn't describe the exact return format beyond 'batchId' or error scenarios, but given the comprehensive schema coverage and clear workflow guidance, it's nearly complete. The absence of output schema means some return value details are 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?

With 100% schema description coverage, the baseline is 3. The description adds some context about 'variableSets' ('Each variable set produces a separate image') and mentions the 100-item limit, but doesn't provide significant additional parameter semantics beyond what's already well-documented in the schema. The schema descriptions are comprehensive for all 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 clearly states the specific action ('Start a batch render job'), resource ('multiple images from a single template'), and scope ('with different variable sets'). It explicitly distinguishes this tool from its sibling 'pictify_render_multi_page_pdf' for single multi-page PDF generation, providing clear differentiation.

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 explicit workflow guidance (steps 1-3 with specific sibling tool names), clear when-to-use examples (personalized social cards, product images, etc.), and explicit when-not-to-use guidance ('For generating a single multi-page PDF instead, use pictify_render_multi_page_pdf'). This gives comprehensive context for tool selection.

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?

Discloses behavioral traits: completed items retain results, remaining skipped. No annotations exist, so description carries full burden and does well.

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, no wasted words.

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?

Simple tool with one param and no output schema. Description covers action, effects, and use case. Adequate for the tool's complexity.

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

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

Schema has 100% coverage for the single parameter batchId with a clear description. The tool description adds no additional parameter meaning beyond what the schema provides.

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 it cancels a running batch render job, using a specific verb and resource. It distinguishes from sibling tools like pictify_batch_render (starts batch) and pictify_get_batch_results (gets results).

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 says to use when started with incorrect data or no longer need results. Does not explicitly mention when not to use, but context is clear.

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 explains the mechanism (headless browser, recording over time), the time cost proportional to duration, and that it returns a hosted URL. It does not confirm whether the operation is read-only, but it implies a non-destructive capture.

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 paragraph that front-loads the main action, then provides use cases, an alternative, and return value. Every sentence adds information without 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?

Given 5 parameters, full schema coverage, and no output schema, the description covers the return format (hosted GIF URL) and differentiates from a sibling. It could mention error scenarios (e.g., inaccessible URL) or page load requirements, but the current detail is 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 coverage is 100%, so the schema already documents each parameter. The description adds value by explaining quality presets with fps/duration limits, and the trade-off between quality and file size. It also notes that the URL must be publicly accessible.

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 records a GIF from a live web page URL using a headless browser. It lists specific use cases (CSS/JS animations, interactive demos, UI transitions, product walkthroughs) and directly distinguishes itself from the sibling tool pictify_create_gif, which is for custom HTML.

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 when to use this tool vs. pictify_create_gif (live sites vs. custom HTML). It also notes that operation time scales with duration. It could be more explicit about when not to use it (e.g., static pages), but the alternative is clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates critical behavioral traits: this is a final action that cannot be undone, it routes all traffic to the winning variant, and it only accepts specific state transitions (running->completed, paused->completed). However, it doesn't mention potential side effects like quota impacts or error conditions, leaving some behavioral aspects uncovered.

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 efficiently structured with three sentences that each serve a distinct purpose: stating the action, warning about finality and traffic routing, and providing workflow guidance. There is no wasted text, and the most critical information (finality) is front-loaded appropriately.

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 mutation tool with no annotations and no output schema, the description does an excellent job covering the essential context: purpose, irreversible nature, state requirements, and workflow. The main gap is the lack of information about return values or error responses, which would be helpful given the absence of an output schema. However, it provides sufficient guidance for safe usage.

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

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

The schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds minimal value beyond the schema by reinforcing that winnerVariantId must be from the experiment's variants and suggesting pictify_get_experiment to see them, but this is largely redundant with the schema's description. This meets the baseline of 3 for high 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 specific action ('complete an experiment by declaring a winning variant'), identifies the resource ('experiment'), and distinguishes it from siblings like pictify_pause_experiment or pictify_update_experiment by emphasizing its finality. The verb 'complete' is precise and differentiates from other experiment lifecycle tools.

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 explicit guidance on when to use this tool: after checking pictify_get_experiment to review data, and only for experiments in 'running' or 'paused' states. It also names the specific alternative tool (pictify_get_experiment) for prerequisite data gathering, creating a clear workflow 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?

No annotations provided, so description carries full burden. Discloses return value ('hosted image URL, CDN-backed') but lacks details on auth requirements, rate limits, or side effects. Does not explicitly state read-only or destructive nature, though 'generate' implies non-destructive.

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 sentences, front-loaded with purpose and usage guidelines. Every sentence adds value, no redundancy or wasted words.

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?

Covers the core functionality, return value, and distinction from sibling tool. Could mention potential limitations or error conditions, but given the complexity and no output schema, it's fairly 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?

All 6 parameters have schema descriptions (100% coverage), and the description adds meaningful context beyond the schema, e.g., explaining variable substitution and FabricJS JSON structure. Provides a brief overview of what variables and fabricJSData are.

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?

Clearly states 'Generate an image from FabricJS canvas JSON data with optional variable substitution', specifying the verb (generate), resource (image from JSON), and feature (variable substitution). Explicitly distinguishes from sibling tool pictify_render_template by stating when to use each.

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?

Provides precise guidance: 'Use this when you have a FabricJS canvas design...' and 'For rendering a saved template, use pictify_render_template instead'. Also notes that it renders directly without saving as template first.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the experiment starts in 'draft' status, requires unique slugs for URLs, and includes constraints like variant weight sums (10000 basis points) and slug formatting rules. However, it lacks details on error handling, rate limits, or authentication needs, which are important for a creation 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?

The description is well-structured and front-loaded, starting with the core purpose and workflow steps, followed by key constraints and usage tips. Every sentence adds value—none are wasted—and it efficiently covers prerequisites, slug rules, and banditConfig usage in a compact format.

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

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

Given the tool's complexity (13 parameters, nested objects) and lack of annotations or output schema, the description does a good job of providing context. It explains the workflow, constraints, and key behavioral aspects. However, it could improve by mentioning error responses or the structure of the created experiment object, as there's no output schema to fill 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?

The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal parameter semantics beyond the schema, such as clarifying that the slug 'becomes part of the experiment URL' and that variant weights use 'basis points (i.e., 5000 = 50%)', but most details are redundant. This meets the baseline for high 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 specific action ('Create a new experiment') and resource ('to test different image variants'), distinguishing it from siblings like pictify_update_experiment or pictify_get_experiment. It explicitly mentions the creation of experiments with variants, which is distinct from other tools that handle rendering, tracking, or management.

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 explicit guidance on when to use this tool as part of a workflow (steps 1-4), naming specific sibling tools (pictify_start_experiment, pictify_get_experiment, pictify_complete_experiment) for subsequent actions. It also includes prerequisites ('Requires at least 2 variants') and context for when to enable banditConfig ('For A/B tests'), offering clear alternatives and 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 carries full burden. It discloses required animation content, maximum dimensions, and return values, but omits authentication needs, rate limits, or side effects.

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 well-structured, each sentence adds value, and it is appropriately sized for the tool's complexity with no wasted words.

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

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

Given the absence of an output schema, the description adequately covers return values, input constraints, and usage patterns. It lacks details on persistence or error conditions but is largely complete for a creation 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 coverage is 100%, so baseline is 3. The description adds mutual exclusivity context, template variable dependency, and practical limits like dimension maximums, elevating it above mere schema repetition.

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 it creates an animated GIF from HTML, URL, or template, and explicitly distinguishes from pictify_capture_gif for live website recording.

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 explicit guidance on when to use each parameter (one of html, url, template+variables) and directs to an alternative for live recording. It lists common use cases but doesn't cover all sibling 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 provided, the description carries full burden and does well by disclosing key behavioral traits: the tool returns a hosted image URL (CDN-backed) and asset ID, has maximum dimension constraints (4000x4000 pixels), and supports specific input methods. It doesn't mention rate limits, authentication requirements, or error conditions, but provides substantial operational context for a creation 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?

The description is efficiently structured in three sentences: first states core functionality, second provides use cases, third explains input options and output. Every sentence earns its place with no redundancy. It's appropriately sized for an 8-parameter tool with no annotations.

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 creation tool with 8 parameters, 100% schema coverage, but no annotations and no output schema, the description provides good context about what the tool creates, common use cases, input constraints, and output format. It could be more complete by mentioning authentication requirements, rate limits, or error handling, but covers the essential operational context well given the schema richness.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds minimal value beyond the schema - it mentions the three mutually exclusive input options (html, url, template+variables) and maximum dimensions, but doesn't provide additional parameter semantics that aren't already in the schema descriptions. Baseline 3 is appropriate when 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 clearly states the verb ('Generate') and resource ('static image') with specific formats (PNG, JPEG, WebP) and three distinct input methods (HTML/CSS, URL screenshot, template). It explicitly distinguishes this tool from sibling tools like pictify_create_gif, pictify_render_pdf, and pictify_batch_render by focusing on single static image generation rather than animated GIFs, PDFs, or batch operations.

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 context for when to use this tool through common use cases (Open Graph images, social media cards, screenshots, etc.) and mentions the three mutually exclusive input options. However, it doesn't explicitly state when NOT to use it (e.g., for animated content use pictify_create_gif, for batch operations use pictify_batch_render) or provide direct alternatives among 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?

With no annotations provided, the description carries the full burden. It discloses the mutually exclusive parameter choice, the expression engine capabilities, and the return value (template ID). It could mention potential errors or limits but is sufficiently 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 well-structured, front-loading the main purpose. It is detailed but not verbose, with each sentence adding value. Slightly long but within reason.

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

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

Given 10 parameters, nested objects, no output schema, and no annotations, the description covers the core functionality, modes, variable syntax, and links to a sibling tool. It could explicitly mention the required 'name' parameter but is generally 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%, so the baseline is 3. The description adds context about expression syntax and use cases but doesn't significantly enhance the schema descriptions. It does explain the two main options and their purpose.

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 creates a reusable template with variable placeholders, distinguishing it from sibling tools like pictify_render_template and pictify_update_template. It specifies the two mutually exclusive content sources (FabricJS canvas data or raw HTML), providing a specific verb and resource.

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 states the mutual exclusivity of 'html' and 'fabricJSData' and advises using pictify_render_template after creation. While it doesn't explicitly list when not to use it, the context is clear enough for an AI 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates critical traits: it's a destructive operation ('This cannot be undone'), specifies prerequisites for safe use, and clarifies the deletion type ('soft-delete'), which implies potential recovery mechanisms not detailed but hints at non-permanent removal.

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 front-loaded with the core action and key warnings in just two sentences, with zero wasted words. Each sentence earns its place by conveying essential information: the tool's purpose, irreversibility, and usage prerequisites, making it highly efficient and well-structured.

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

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

Given the tool's complexity as a destructive operation with no annotations or output schema, the description is largely complete. It covers purpose, behavioral risks, and prerequisites. A minor gap is the lack of details on what 'soft-delete' entails (e.g., recovery options or system behavior), but it provides sufficient context for safe agent use.

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 100% description coverage, fully documenting the single parameter 'experimentId'. The description does not add any additional meaning beyond the schema, such as format examples or constraints, so it meets the baseline score of 3 where the schema handles parameter documentation adequately.

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 specific action ('soft-delete') and resource ('an experiment'), distinguishing it from siblings like pictify_complete_experiment or pictify_pause_experiment. It precisely defines what the tool does without being vague or tautological.

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 context for when to use this tool by specifying prerequisites ('Running experiments must be paused or completed first before deletion'). However, it does not explicitly mention when not to use it or name alternatives, such as pictify_update_experiment for modifications instead of deletion.

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 provided, so description carries full burden. It clearly discloses the destructive nature (permanent, cannot be undone) and cascading impact on dependent entities, which is essential for an agent deciding to invoke this 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?

Two concise sentences with critical information front-loaded: action, irreversibility, and warning. Every word earns its place.

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

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

For a single-parameter delete operation with no output schema, the description covers all necessary context: what it does, that it's irreversible, and what consequences occur. No gaps.

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 a clear parameter description ('The template UID to delete'). The tool description adds no further detail about the parameter beyond confirming it identifies the template, resulting in a baseline score of 3.

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

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

The description clearly states the action ('Permanently delete a template') with a specific verb and resource. It distinguishes from sibling tools like pictify_create_template and pictify_update_template by emphasizing deletion.

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 warns about irreversibility and side effects ('Any batch jobs, experiments, or bindings using this template will stop working'), guiding the agent on when to use (only when permanent deletion is intended) and implications.

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 disclosure. It transparently explains the return structure (status, progress, item details, error messages) and polling behavior, providing adequate transparency for a read operation.

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

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

The description is concise at 3 sentences, each providing essential information: purpose, return fields, and usage instructions. No redundancy, though it could be slightly more streamlined.

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 status-checking tool with one parameter and no output schema, the description fully covers what the agent needs: how to call, what to expect, and what to do next. It's complete and actionable.

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 a clear description for batchId. The description adds value by linking it to pictify_batch_render, telling the agent where to get the ID, which exceeds baseline expectations.

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 the status and results of a batch render job, listing possible statuses and output details. It distinguishes itself from siblings like pictify_batch_render and pictify_cancel_batch, demonstrating a specific verb-resource combination.

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 says to call this after pictify_batch_render and advises polling when status is 'processing'. While it doesn't mention when not to use, the guidance is clear and contextually sufficient.

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. It discloses that this is a read operation ('Get detailed information') and lists the comprehensive data returned, which helps the agent understand the tool's behavior. However, it lacks details on error handling, rate limits, or authentication needs, leaving some behavioral aspects unclear.

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 appropriately sized and front-loaded: the first sentence states the core purpose, the second enumerates the returned data, and the third provides usage context. Every sentence adds value without redundancy, making it efficient and well-structured.

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

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

Given the tool's complexity (retrieving detailed experiment data) and the absence of annotations and output schema, the description does a good job by listing the specific fields returned and providing usage guidance. However, it could be more complete by mentioning the response format or potential errors, which would help the agent handle the tool more effectively.

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% (the experimentId parameter is fully documented in the schema as 'The experiment UID to retrieve'), so the baseline is 3. The description does not add any additional meaning or context about the parameter beyond what the schema provides, such as format examples or validation rules.

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 detailed information') and resource ('about a specific experiment'), distinguishing it from siblings like pictify_list_experiments (which lists multiple experiments) and pictify_update_experiment (which modifies experiments). It specifies the exact scope of information returned, making the purpose highly specific.

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 context for when to use this tool ('to monitor experiment performance and review setup before making changes'), which implicitly suggests alternatives like pictify_update_experiment for changes. However, it does not explicitly state when not to use it or name specific alternative tools, keeping it at a 4.

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

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

With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it's a read-only check (implied by 'check' and 'returns'), specifies the return data structure (quota usage per experiment type, maximum variants, analytics retention), and hints at usage constraints ('before creating experiments'). However, it lacks details on rate limits or authentication needs.

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?

It is front-loaded with the core purpose in the first sentence, followed by specific return details and usage guidance in the second. Every sentence adds value without waste, making it efficient and well-structured.

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

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

Given the tool's low complexity (0 parameters, no output schema), the description is largely complete: it explains what the tool does, when to use it, and what it returns. However, without annotations or an output schema, it could benefit from more detail on error handling or exact return formats, but this is minor for a simple read operation.

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

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

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately adds no parameter information, as none are needed, avoiding redundancy and focusing on the tool's purpose and output.

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's purpose with specific verbs ('check experiment usage and limits') and resources ('experiment quota'), distinguishing it from sibling tools like 'pictify_get_experiment' or 'pictify_list_experiments' by focusing on quota metrics rather than experiment details or listings.

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

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

It explicitly provides when-to-use guidance: 'Use this before creating experiments to check if you have quota remaining.' This directly advises on the tool's context and purpose relative to other operations, such as 'pictify_create_experiment'.

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

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

With no annotations provided, the description carries the full burden for behavioral transparency. It discloses that no authentication is needed and specifies the return fields (URL, dimensions, animation details). This is sufficient for a simple retrieval tool, though it could mention error handling or rate limits.

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 two short sentences, front-loading the purpose and key details. Every sentence adds value, no redundancy or irrelevant 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 one-parameter retrieval tool without an output schema, the description covers the essential behavioral aspects: what it returns (URL, dimensions, animation details) and authentication status. It could mention possible error conditions or if the GIF is public/private, but it is largely 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 input schema has one parameter 'gifId' with description 'The GIF UID to retrieve', and the description adds 'by its UID', but this does not significantly improve understanding beyond the schema. With 100% schema coverage, baseline score 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 clearly states the verb 'Get' and the resource 'details of a specific GIF by its UID', which distinguishes it from sibling tools like 'pictify_list_gifs' (list all GIFs) and 'pictify_get_image' (different resource). The purpose 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 mentions 'No authentication required', which is helpful, but does not provide explicit guidance on when to use this tool versus alternatives like 'pictify_list_gifs' or 'pictify_get_image'. Usage context is implied but lacks when-not or alternative recommendations.

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?

Without annotations, the description carries the behavioral transparency burden. It mentions the return fields but does not explicitly state the tool is read-only, idempotent, or requires specific permissions. It adds some value by listing outputs but lacks safety or side-effect disclosure.

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 primary purpose, and no redundant information. Every word earns its place, achieving high conciseness.

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 single-parameter retrieval tool with no output schema, the description adequately covers purpose and output fields. It does not mention error conditions or authentication, but it is reasonably complete given the low complexity.

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

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

Schema coverage is 100% with a clear description for the only parameter (imageId as 'The image UID to retrieve'). The tool description adds no additional meaning beyond confirming retrieval 'by its UID,' so 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 clearly states the tool retrieves details of a specific image by its UID, listing the specific return fields (URL, dimensions, format, timestamp). This distinguishes it from sibling tools that get other resources (e.g., get_gif, get_template) or batch operations.

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 you need image details and have the UID, but it does not explicitly provide guidance on when not to use the tool or mention alternatives like list_images if the UID is unknown. The context is clear but lacks 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?

Discloses specific return fields (name, dimensions, variables, etc.) and implies read-only behavior. No annotations present.

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 purpose, no filler. Every sentence adds value.

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?

Describes return fields sufficiently for a retrieval tool, though error handling or other details are omitted.

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 one parameter; description adds no extra meaning beyond what the schema already provides.

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 starts with a clear verb ('Get') and resource ('detailed information about a specific template'), and it's distinct from sibling tools like list and render.

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?

Provides explicit context for use ('before rendering'), but does not mention when not to use or alternative tools.

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 provided, so the description carries full burden. It details what the tool returns (names, types, defaults, descriptions) and mentions the expression engine capabilities. It does not specify non-destructive nature or auth requirements, but for a simple read operation, this is adequate.

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: first states purpose, second gives critical usage instruction and return type summary. No wasted words, information front-loaded.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, usage, return content, and expression engine. Missing details about potential errors or format of variable descriptions, but overall adequate.

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?

Input schema has 100% description coverage for its single parameter 'templateId', so baseline is 3. The description does not add additional context beyond schema, so no increase.

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 retrieves variable definitions for a template and distinguishes it from sibling tools by explicitly naming it as a prerequisite for render operations.

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 explicit guidance: 'Always call this before pictify_render_template, pictify_batch_render, pictify_render_pdf, or pictify_render_multi_page_pdf' — directly telling when to use and listing alternative tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: it's a read operation (implied by 'List'), returns paginated results, provides details about experiment types with clear explanations, and specifies the return data structure (names, IDs, types, statuses, variant details, pagination info). This covers most behavioral aspects well for a 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?

The description is perfectly structured: first sentence states the core purpose, second provides domain context, third explains parameter values with clear examples, and fourth specifies return values. Every sentence earns its place with zero wasted words, making it highly scannable and informative.

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 listing tool with 4 parameters, 100% schema coverage, and no output schema, the description provides excellent context. It explains the domain (Pictify experiments), details the experiment types with concrete examples, specifies the return data structure, and mentions pagination. The only minor gap is not explicitly stating this is a read-only operation, though that's strongly implied by 'List'.

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

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

The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds some value by mentioning 'optional filtering by type and status' and providing context about experiment types, but doesn't add significant semantic information beyond what's already in the parameter descriptions. This meets the baseline for high 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 verb ('List') and resource ('A/B test experiments') with specific scope ('with optional filtering by type and status'). It distinguishes from siblings like 'pictify_get_experiment' (singular retrieval) and 'pictify_create_experiment' (creation) by focusing on listing with filtering capabilities.

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 context for when to use this tool ('List A/B test experiments with optional filtering by type and status') and mentions what it returns, but doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools. The filtering guidance is helpful but not comprehensive for sibling differentiation.

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 provided. Description indicates a read-only list operation but does not disclose potential rate limits, authentication needs, or idempotency. Basic transparency, but no contradictions.

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, highly concise. Every word adds value: lists purpose, returned data, and usage recommendation. No fluff.

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 list tool with two parameters and no output schema, the description covers purpose, return fields, and usage. Missing pagination iteration details, but overall adequate.

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 parameter descriptions. The tool description mentions pagination generally but does not add new semantics beyond the schema. Baseline score 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?

Description clearly states it lists previously generated GIFs with pagination, specifying returned fields. Distinguishes itself from siblings like pictify_get_gif (single GIF) and pictify_create_gif (creation).

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 states when to use ('browse your GIF history or find a previously generated animation'). Does not provide exclusions or compare directly to alternatives, but context is clear.

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 provided, so the description bears full burden. It discloses pagination and return fields but omits details like ordering, authentication needs, or rate limits. The description conveys basic read-only 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 sentences, no redundant information. Every word adds value: verb, resource, pagination, return fields, and usage hint. Exceptionally 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 list tool with no output schema, the description covers input parameters and return fields. Lacks details on ordering but is otherwise complete for its complexity level.

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

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

Schema coverage is 100% with descriptions for limit and offset. The description adds context about pagination but does not enhance parameter semantics beyond what the schema provides. Baseline score 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 clearly states the tool lists images with pagination and specifies what it returns (URLs, IDs, dimensions, format, timestamps). It distinguishes from siblings like pictify_get_image (single image) and pictify_list_gifs (gifs).

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 says 'Use this to browse your render history or find a previously generated image', providing clear context. It does not mention when not to use or alternative tools, but the usage is unambiguous.

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 provided, so description carries full burden. It describes a read-only list operation with no side effects, which is clear, but could explicitly state it's safe and does not modify anything. Still, it's adequately transparent for a simple list 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?

Two sentences front-load purpose and usage guidance, with no wasted words. Examples are included concisely.

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

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

Given the tool's simplicity (0 parameters, no output schema), the description is complete. It covers purpose, usage, and examples, with no missing information.

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?

Input schema has 0 parameters, baseline is 4. Description adds significant value by explaining the output contains dimensions and how to use preset names, going beyond the empty 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 clearly states it lists all PDF page size presets with dimensions, using specific verb 'List' and resource. It distinguishes from siblings by focusing on presets and mentioning their use in render tools.

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 instructs to use preset names when calling pictify_render_pdf or pictify_render_multi_page_pdf, providing clear when-to-use guidance and examples of common presets.

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 full burden. It explains that the tool returns template names, IDs, dimensions, output formats, and pagination info. However, it does not disclose auth requirements, rate limits, or whether it lists templates for the authenticated user only. The description is adequate but lacks some behavioral details.

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 two concise sentences: the first states the purpose, the second explains the context and return values. It is front-loaded and each word adds value, with no 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?

Given no output schema, the description covers return values and the concept of templates. It explains what templates are and why to list them. However, it lacks details on error handling or authentication, but for a list tool, it is fairly 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%, so baseline is 3. The description adds context by explaining what templates are (reusable designs with variable placeholders) and mentions pagination/filtering, but does not add significant meaning beyond the schema parameters themselves.

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 'list' and the resource 'saved templates' within a Pictify account, including pagination and filtering capabilities. It distinguishes this tool from siblings like pictify_render_template and pictify_create_template by focusing on discovery before rendering.

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 recommends using this tool to 'discover available templates before rendering,' providing a clear use case. While it doesn't state when not to use it, the mention of 'before rendering' differentiates it from other listing tools like pictify_list_experiments.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the state transition constraint (running → paused), the temporary nature of pausing, data preservation, and the resumable capability. However, it doesn't mention potential side effects like whether paused experiments still count against quotas or if there are time limits for pausing.

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 efficiently structured in three sentences: the core action, the state transition constraint, and the preservation/resumption context. Every sentence adds essential information without redundancy, making it easy to parse and understand quickly.

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 mutation tool with no annotations and no output schema, the description does well by covering the action, preconditions, data handling, and resumption path. However, it doesn't specify what the tool returns (e.g., success confirmation or updated experiment state), which would be helpful given the lack of output 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 100%, with the single parameter 'experimentId' clearly documented in the schema. The description doesn't add any parameter-specific information beyond what the schema provides (e.g., format examples or validation rules), so it meets the baseline for high schema coverage without adding extra value.

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 specific action ('pause a running experiment') and distinguishes it from siblings by specifying the valid state transition (running → paused). It explicitly names the alternative tool for resuming (pictify_start_experiment), making the purpose unambiguous and distinct from related tools like pictify_cancel_experiment or pictify_complete_experiment.

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 explicit guidance on when to use this tool: only for experiments currently in the 'running' state, with a named alternative for resuming (pictify_start_experiment). It also clarifies what the tool does not do (data is preserved, not deleted), which helps differentiate it from destructive siblings like pictify_delete_experiment.

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

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

With no annotations provided, the description carries the full burden. It discloses the output format ('single combined PDF URL'), page limit (1-100), and the need for variable sets. However, it does not discuss error handling, authentication, or potential side effects, which would be beneficial. Overall, it provides adequate behavioral context.

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

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

The description is concise and well-structured. It front-loads the primary purpose, then provides details, workflow, and alternatives. Every sentence adds value without 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?

Given the rich input schema (100% coverage) and no output schema, the description adequately explains the input (templateId, variableSets, title, preset) and the output (single PDF URL). It also addresses the range and use cases, making it complete for an agent to use 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?

Schema coverage is 100%, so baseline is 3. The description adds an example for variableSets and clarifies it is one per page, but the schema already provides descriptions for all parameters. The added value is marginal beyond what the schema offers.

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's purpose: generating a multi-page PDF from a template with multiple variable sets. It uses a specific verb ('generate') and resource ('multi-page PDF'), and distinguishes from sibling tools like pictify_batch_render and pictify_render_template. The inclusion of use cases further clarifies the intended functionality.

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 explicit workflow guidance ('Call pictify_get_template_variables first') and clearly states when to use an alternative ('For generating separate image files per set, use pictify_batch_render instead'). This helps the agent decide between tools.

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 provided, so description carries full burden. It discloses it returns a hosted PDF URL and that it's single-page. However, it lacks details on side effects, error handling, or permission requirements. The description is adequate but not rich in behavioral context.

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?

Well-structured: purpose first, then common use cases, then step-by-step workflow. Every sentence adds value; no redundancy. Length is appropriate for the tool's complexity.

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?

Describes input (template, variables, preset), workflow, and output (hosted PDF URL). Missing details about error conditions or validation. For a single-purpose generation tool, it covers the essential context adequately.

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 baseline is 3. Description adds value by explaining the workflow for variables (use get_template_variables) and preset (use list_pdf_presets). This goes beyond schema descriptions, providing strategic guidance.

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?

Description clearly states it generates a single-page PDF from a saved template with variable substitutions, listing common use cases. It explicitly differentiates from siblings by specifying 'single-page' (contrast with pictify_render_multi_page_pdf) and mentions batch rendering alternatives.

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?

Provides explicit workflow: call pictify_get_template_variables first to discover variables, then use this tool. Also advises using pictify_list_pdf_presets for page size options. Does not explicitly state when not to use or alternatives, but the workflow is clear.

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 full burden and does well by disclosing: the workflow process, return value (hosted image URL with CDN backing), and behavioral context about template types (FabricJS/HTML). It doesn't mention rate limits, authentication requirements, or error conditions, but provides substantial operational guidance.

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 efficiently structured with clear workflow steps, use cases, and alternative tool reference. Every sentence adds value: first defines the core function, second explains template types, third provides workflow, fourth lists use cases, fifth gives alternative, sixth describes return value. No wasted words.

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 4-parameter tool with no annotations and no output schema, the description provides excellent workflow context, sibling tool relationships, and return value information. It could improve by mentioning error conditions or authentication requirements, but covers the essential operational context well given the complexity.

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

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

With 100% schema description coverage, the baseline is 3. The description adds minimal parameter semantics beyond the schema - it mentions 'variable substitutions' which aligns with the variables parameter, but doesn't provide additional context about templateId format, variable validation, or quality/format interactions beyond what's in the schema descriptions.

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 specific action ('Render a saved template with variable substitutions') and resource ('to produce an image or PDF'), distinguishing it from siblings like pictify_batch_render (batch processing) and pictify_render_pdf (PDF-specific rendering). It explicitly mentions both FabricJS canvas designs and HTML templates.

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 explicit workflow guidance (3-step process referencing sibling tools pictify_list_templates and pictify_get_template_variables), clear alternatives (use pictify_batch_render for multiple variable sets), and specific use cases (OG images, social cards, product images, event banners). It tells agents exactly when to use this tool versus other options.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure and does so effectively. It describes key behavioral traits: the tool activates traffic routing, serves variants, tracks events, and includes details about Thompson Sampling optimization for banditConfig. However, it lacks information on error conditions, rate limits, or authentication needs, which are minor gaps.

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 appropriately sized and front-loaded, with three sentences that each add value: the first states the core action, the second details transitions and effects, and the third explains banditConfig behavior. There is no wasted text, and information is structured logically from general to specific.

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

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

Given the tool's complexity (state transitions, traffic routing, event tracking) and lack of annotations or output schema, the description is largely complete. It covers purpose, usage, and behavioral aspects well. However, it does not specify return values or error handling, which are minor omissions in an otherwise thorough description.

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 the single parameter (experimentId). The description does not add any parameter-specific semantics beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when the schema handles parameter documentation adequately.

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's purpose with specific verbs ('start', 'activating traffic routing') and resources ('draft or paused experiment'), distinguishing it from siblings like pictify_pause_experiment and pictify_complete_experiment. It explicitly mentions what happens after starting (serves variants, tracks events), making the action concrete and distinct.

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 explicit usage guidelines by specifying valid state transitions ('draft -> running, paused -> running'), indicating when to use this tool versus alternatives like pictify_pause_experiment or pictify_complete_experiment. It also mentions prerequisites (experiment must be in draft or paused state) and context (banditConfig for A/B tests), offering clear when-to-use criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure and excels at this. It clearly explains authentication requirements (API key/Bearer token, client-side alternatives), rate limits (1000 requests/minute per IP), and operational constraints (accepts single event or array up to 100 events). This provides comprehensive behavioral context beyond what the input schema offers.

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 perfectly structured and front-loaded with the core purpose, followed by essential operational details. Every sentence earns its place by providing critical information about usage, authentication, and constraints without any wasted words 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 tool with no annotations and no output schema, the description provides excellent coverage of behavioral aspects (authentication, rate limits, constraints). However, it doesn't describe what happens after successful tracking or potential error scenarios, which would be helpful given the absence of output schema. The single parameter is well-covered by the 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?

The schema description coverage is 100%, so the schema already documents the single 'events' parameter thoroughly. The description adds minimal value beyond the schema by mentioning 'single event or an array of up to 100 events' which is already covered in the schema's minItems/maxItems. This meets the baseline expectation when schema coverage is high.

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 specific action ('Track impressions, views, clicks, and conversions') and resource ('for experiments'), distinguishing it from sibling tools that focus on rendering, management, or retrieval operations. It precisely identifies the tool's function as sending event data to Pictify's analytics.

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 context on when to use this tool ('to send event data from your application to Pictify's analytics') and offers guidance on authentication methods for different scenarios (API key vs. client-side tracking). However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the mutation behavior (updating experiments) and adds critical context about status-dependent field editability and the weight-sum constraint for variants. However, it doesn't mention permissions, rate limits, or what happens to unspecified fields during updates, leaving some behavioral aspects uncovered.

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 front-loaded with the core purpose, followed by a bulleted list that efficiently organizes status-dependent rules and constraints. Every sentence earns its place by providing essential usage guidance without redundancy, making it highly structured and concise for a complex 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?

Given the complexity (11 parameters, nested objects, no output schema, and no annotations), the description does well by covering status-dependent editability and key constraints. However, it lacks details on error conditions, response format, or side effects (e.g., whether updates affect running experiments immediately), which would be helpful for full contextual understanding.

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 significant value beyond the schema by explaining which parameters are editable based on experiment status (e.g., slug only when draft/paused, confidenceThreshold only when running) and reinforcing the weight-sum rule for variants. This status-dependent semantics is not captured in the schema descriptions, elevating the score.

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 specific action ('Update an existing experiment') and resource ('experiment'), distinguishing it from siblings like pictify_create_experiment (creation), pictify_delete_experiment (deletion), and pictify_get_experiment (retrieval). It provides a verb+resource combination that is unambiguous in context.

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 defines when to use this tool based on experiment status (draft/paused, running, completed), specifying which fields are editable in each state. It provides clear context for usage without needing to reference alternatives, as the status-based rules inherently guide when this tool is applicable versus when creation or deletion might be needed.

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?

Discloses partial update behavior, mutual exclusivity of html and fabricJSData, and that updating content may change available variables. With no annotations, these behavioral traits are well covered, though side effects on variable definitions when not explicitly updated could be clarified.

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 adding distinct information: purpose, partial update, mutual exclusivity and side effect. No redundancy, front-loaded with the core action.

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

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

Given the tool's complexity (7 params, no output schema, nested objects), the description covers key behaviors and constraints. However, it is unclear whether providing variableDefinitions replaces all definitions or merges, and no return value info is provided.

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 covers all parameters with descriptions (100% coverage). Description adds value by summarizing partial update semantics and mutual exclusivity, reinforcing schema info but not adding significant new 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?

Description clearly states the tool updates an existing template's content, dimensions, name, or variable definitions. It distinguishes from sibling create/delete tools and explicitly notes partial update behavior and mutual exclusivity of html and fabricJSData.

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 modifying existing templates but does not explicitly contrast with alternatives like pictify_create_template. No 'when to use' or 'when not to use' guidance is provided.

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