designforyou

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

Annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true) provide basic safety info. The description adds behavioral detail about duration normalization, which is helpful. 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, front-loaded with key action and result. No superfluous words; 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?

With 7 parameters, no output schema, and sibling tools for differentiation, the description is minimal. It does not explain return values, error conditions, or how it differs from similar tools. Adequate but leaves 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 description coverage is 57%. The description clarifies the duration parameter's effect ('normalized to requested source duration') but does not elaborate on other parameters lacking descriptions (model, aspect_ratio). Some value added but incomplete.

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 generates a short image-to-video take using Grok from one reference frame and normalizes to source duration. It is specific but does not explicitly distinguish from siblings like 'animate_reference_image' or 'animate_reference_video'.

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 for image-to-video animation with Grok but offers no explicit guidance on when to use this tool versus alternatives, nor any prerequisites or contexts to avoid.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, meaning the tool creates new content without destroying existing data. The description adds behavioral context: it generates a short vertical video, accepts specific URL types, and implies motion generation. No contradictions with annotations.

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 very concise: two sentences covering purpose, output format, and input source options. Every sentence adds value without redundancy. It is 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 has 7 parameters and no output schema, the description is somewhat terse. It does not explain the role of parameters like 'model', 'duration', or 'aspect_ratio', nor does it describe the return format. The description is adequate but leaves gaps for an AI to infer.

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 57%, and the description adds minimal parameter details beyond what the schema provides. The schema already describes 'prompt', 'line', 'image_url', and 'image_data_url' with useful context. The description only reiterates the URL option, adding little new meaning.

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 function: 'Generate a short vertical image-to-video take from one supplied reference frame.' It distinguishes from sibling tools like 'generate_character_video' by specifying the use of a reference frame and vertical format. The mention of URL types further refines the purpose.

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 context for when to use this tool: 'when exact source style and composition need to anchor the shot.' It does not explicitly state when not to use it or list alternatives, but the guidance is clear enough for typical use cases.

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

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

Annotations indicate non-destructive mutation (readOnlyHint=false, destructiveHint=false). The description adds context about preserving attributes but does not disclose potential side effects, auth requirements, or output specifics. With annotations present, the added value is moderate.

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 two sentences, front-loading the core action. 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?

With 7 parameters, no output schema, and moderate complexity, the description is too brief. It fails to explain output format, input constraints, or how parameters interact, leaving significant gaps for agent execution.

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 57% (4 of 7 parameters have descriptions). The description omits guidance on parameters like model, duration, and aspect_ratio, which lack schema descriptions. Without compensatory detail, agents must infer usage.

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 generates a short video from a source clip, preserving attributes like actors and style. It distinguishes from still-frame reference but does not explicitly differentiate from sibling tools like animate_reference_image or animate_reference_grok_video.

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 use when preserving source attributes is important, but provides no explicit guidance on when not to use it or alternatives. Sibling tools exist for different inputs (image vs video) but are not mentioned, leaving selection unclear.

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?

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description adds output format ('normalized 9:16 MP4') and input source types (local paths or HTTPS URLs). This provides meaningful behavioral context, though it does not cover all behavior like audio handling or return value.

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 consists of two efficient sentences with no wasted words. It front-loads the core action and follows with essential context, making it immediately scannable for an AI agent.

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 9 parameters and no output schema, the description is insufficiently complete. It omits details on how optional parameters (audio, durations, overrides) work, the return value, and concatenation logic, leaving gaps for proper invocation.

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

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

Schema description coverage is 67%, so the baseline is 3. The description does not detail individual parameters beyond mentioning 'ordered video segments or URL sources', which aligns with segments/segment_urls. It adds no extra meaning for fps, width, height, or other parameters lacking 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 uses the specific verb 'assemble' and resource 'shortform reel', clearly stating it creates a normalized 9:16 MP4 from segments. It is distinct from all sibling tools, none of which compose video, making its purpose 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 frames this as the 'missing composition step for multi-take LetMeActForYou stories', providing clear context for when to use it. It implies usage after generating segments, but does not explicitly list exclusion criteria or alternatives among siblings, though no alternative exists.

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

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

Annotations indicate readOnlyHint=false (mutating), destructiveHint=false, and openWorldHint=true. The description adds key behavioral details: the action is billed, it returns an audition_id immediately, and the video is produced asynchronously via polling. No contradictions with annotations.

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 efficient, front-loading the purpose and then providing key workflow details. While every sentence adds value, it could be slightly more concise without losing clarity.

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 (asynchronous, billed, polling pattern, 6 parameters, no output schema), the description covers the main workflow and essential references. However, it lacks details on error handling or timeout scenarios, which would be helpful.

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 each parameter already having a clear description. The tool description reuses some schema info (e.g., 'Get actor_id from casting_roster') but does not add substantial new meaning beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool starts a casting audition, specifies it produces a short vertical video, and distinguishes it from siblings like 'audition_status' and 'casting_roster'. The verb 'Start' and resource 'Audition' are specific and unambiguous.

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

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

The description provides explicit guidance: it says when to use (to start an audition), mentions billing, explains the immediate return of audition_id and subsequent polling of 'audition_status'. It also tells where to get 'actor_id' (from 'casting_roster'), covering necessary prerequisites.

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

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

Annotations already provide readOnlyHint=true. The description adds context that it is 'free to call' and mentions possible statuses, providing extra behavioral insight beyond annotations. 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?

Single sentence packed with key information (status values, video_url, free to call). No waste, front-loaded with purpose.

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?

No output schema, but description sufficiently explains returned status and optional video_url. Could be more detailed about output structure or error states, but adequate for a simple one-parameter 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% with a clear description for audition_id. The tool description adds no additional parameter information beyond what is in the schema, so baseline 3 applies.

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

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

The description clearly states the tool checks audition status (rendering/ready/failed) and provides video_url when ready. The verb 'check' and resource 'audition status' are specific, and it distinguishes from sibling 'audition' which likely creates auditions.

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 after starting an audition ('started with audition') and notes it is 'free to call,' but lacks explicit guidance on when not to use or alternatives. No contrast with siblings like 'comic_status'.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds value by specifying the return content (template IDs, names, previews) and the optional filtering behavior, which is consistent with the annotations.

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 sentences with no wasted words. It front-loads the main action and quickly covers key details (optional filter and return 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?

Given the presence of an output schema (which documents return values) and the annotations, the description is sufficiently complete. It covers the tool's operation, filter behavior, and output summary without requiring further elaboration.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds example values for 'category' but fails to mention 'subcategory', which is a minor gap. Overall, it provides some value but does not fully compensate for the missing subcategory mention.

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 ('Browse the template catalog'), the resource ('DesignForYou template catalog'), and the optional filter by category. It distinguishes from sibling tools like 'recommend_template' by focusing on browsing/filtering rather than recommendations.

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 the tool (browsing/filtering templates) and gives example categories, implying a read-only exploratory use case. It does not explicitly exclude alternatives or state when not to use it, but the purpose is well implied.

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

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

Annotations provide basic hints but the description adds that the tool 'keeps character identity and story provenance across takes,' which is useful behavioral context. However, it does not clarify side effects or idempotency.

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?

Single sentence with no wasted words; conveys the core action and return value. Could be slightly expanded but remains efficient.

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

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

With 6 parameters and no output schema, the description lacks details on prerequisites (e.g., actor and story must exist), uniqueness constraints, and the meaning of 'seeded' or 'private' actors.

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 only 17%: only character_description has a description. The tool description does not explain the roles of actor_id, story_id, notes, source_url, or character_name beyond the schema field names.

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

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

The description states 'Bind a seeded or private actor to one story character' with a clear verb and resources, and mentions the return value (casting_id). It is specific but does not explicitly distinguish from sibling tools like 'audition' or 'casting_roster'.

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

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

No guidance on when to use this tool versus alternatives. The description assumes the actor is 'seeded or private' but does not explain prerequisites or scenarios where other tools are preferred.

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

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

Annotations already declare readOnlyHint=true. Description adds that this is a public catalog and never includes private actors, plus what fields are returned. 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?

Three sentences efficiently cover purpose, scope, and usage order. No redundancy; 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?

Tool is simple with no output schema; description adequately covers purpose, return fields, and usage context. No gaps despite 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?

Only one parameter 'castingrosterinput' which is an empty object; no real parameters to document. Baseline 4 applies as description does not need to add param info.

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 the tool lists the public seeded casting roster with specific fields (headshots, type, bio). Differentiates from sibling tool 'my_actors' by explicitly stating it excludes private actors.

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 when to use: 'Call this first' and gives workflow: show seed actors then call audition with chosen actor_id. Also tells when not to use by naming alternative for private actors.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the description's main value is specifying the contents of the brief. It adds context about what is returned (instructions, schema, templates, success criteria), which is helpful beyond just safety traits.

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 with no waste: first states purpose, second gives usage guidance. All content is essential 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?

While there is no output schema, the description lists the types of content in the return value. Combined with annotations (read-only) and one parameter, the description provides sufficient context for typical usage, though a bit more detail on the brief contents could improve completeness.

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 describes the premise parameter. The description adds minor context by stating the premise is used to author the PanelScript JSON, but this is similar to the schema description. 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 returns a specific authoring brief for Living Panels, with verb 'Return' and resource description. It distinguishes from siblings by mentioning the subsequent call to comic_submit_design, implying a specific workflow for initial design.

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 'Use this when the MCP client will do the creative direction with its own model, then call comic_submit_design', providing clear when-to-use and a follow-up action. This differentiates it from revision and other 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?

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds significant behavioral context by detailing the exact returned components (Story JSON, stale-write hash, allowed patch paths, dirty-node contract), going beyond what annotations provide. No contradiction.

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, each earning its place. Front-loaded with specific outputs, no redundancy or excess. Efficient yet 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 tool with one parameter and no output schema, the description fully explains the return types and the intended workflow (client decides edit then submits). All necessary context 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?

With 100% schema description coverage, the schema already documents the comic_id parameter adequately. The description does not add additional meaning beyond the schema's 'Comic id to revise.' Baseline 3 applies.

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

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

Description explicitly states it returns a specific set of data objects (Story JSON, stale-write hash, etc.) for a comic revision, clearly distinguishing from sibling tools like comic_submit_revision or comic_design_brief.

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?

Description provides clear usage context: 'when the client will decide the edit with its own model, then call comic_submit_revision.' It implies a sequence and to use this before submitting a revision, but does not explicitly list when not to use it.

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

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

Annotations already provide readOnlyHint=true; description adds detail on the data returned (done vs total, ready flag, reader_url) and confirms no cost, adding value beyond annotations.

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, minimal waste, front-loaded with main purpose and key details. 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?

For a single-parameter tool with no output schema, the description fully explains what the tool returns (done/total for three components, ready flag, reader_url) and that it's free. No missing critical 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?

Schema coverage is 100% with comic_id description 'Comic id returned by create_comic'. Description reinforces this but adds no new parameter-level details, so 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 the tool checks asset-production progress for a comic, specifying tracked items (panels, motion clips, voice lines) and the ready flag. It distinguishes itself from sibling tools like create_comic and browse_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?

Implies use after create_comic by referencing it, and notes it's free to call. No explicit when-not-to-use or 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?

Annotations indicate non-readonly, non-destructive, open-world. The description adds behavioral traits: validates, saves, generates character sheets, panel/unit art, motion clips, voice-over, and assembles public reader. This is useful context beyond annotations.

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 action and constraint, then elaboration. Every sentence adds value; 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?

Given complexity (submission triggering pipeline), annotations present, schema complete, no output schema, the description covers the main flow adequately. Lacks error handling or return details but sufficient for selection.

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 description adds minimal value beyond the schema. The schema already describes each parameter well; the description only offers overall process context.

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 accepts a client-authored Living Panels Story JSON and starts artifact production. It distinguishes from siblings by specifying 'without using a server story LLM' and that 'the client does direction', contrasting with other submission tools like comic_submit_revision.

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

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

The description gives clear context: use when client has authored a story and wants production. It implicitly excludes server story generation, but does not explicitly name alternatives or when not to use.

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

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

The description adds value beyond annotations by explaining that targeted changes regenerate only inferred dirty nodes and that using this tool avoids server revision LLM. However, it does not fully describe side effects or prerequisites beyond base_story_hash, even though openWorldHint suggests unpredictable 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 concise with two sentences that front-load the purpose and then explain the effect. Every sentence is informative, 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 tool's 9 parameters and no output schema, the description covers the main behavioral concept well. It mentions the key behavior of targeted node regeneration and the alternative of full story replacement. However, it could be more complete by briefly noting expected outcomes or common use cases.

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 parameters. The description adds general context about targeted changes and dirty nodes but does not elaborate on individual parameters beyond what the schema provides, meeting the baseline expectation.

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 applies a client-authored Living Panels revision without using a server revision LLM, specifying the action, target, and distinguishing behavior. It differentiates from sibling tools like comic_submit_design by focusing on revision submission and targeted changes.

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 (applying a client-authored revision without server LLM) and hints at alternatives (targeted changes vs full story replacement). However, it does not explicitly list when not to use it or compare to all 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds value by detailing the headshot generation, S3 storage, and return of actor_id, providing behavioral context beyond the annotations.

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

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

The description is three sentences long, front-loaded with the primary action, and every sentence provides essential information 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 parameter count and schema coverage, the description covers the essential aspects of creating an actor. It explicitly mentions the return of actor_id and the privacy/reusability. Minor gaps remain on output schema details, but overall 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 only 33%, and the description adds meaningful context for the visual_description parameter (apparent age ranges, physical identity) and hints about headshot_template. However, it does not fully compensate for the low schema coverage on other 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 tool creates a private reusable actor, generates a headshot, and returns an actor ID for use in other tools, distinguishing it from sibling tools like cast_character or audition.

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 provides guidance on what to pass (stable fictional physical identity) and what not to include (performance direction). It does not explicitly state when to use versus alternatives, but the context is clear enough.

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

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

The description discloses key behaviors beyond annotations: it starts generating assets in the background, returns immediately, and takes several minutes to complete. Annotations show readOnlyHint=false, openWorldHint=true, destructiveHint=false, which align with the description. 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?

The description is front-loaded with the core purpose and efficiently conveys the workflow and output. While slightly long, every sentence adds necessary detail. No filler.

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

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

Given the tool has only one parameter and no output schema, the description completely explains what to expect: immediate return of story summary and reader_url, background generation of assets, and polling for completion. It covers all needed context for an agent to use the tool correctly.

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

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

Schema coverage is 100% with a detailed description for the 'premise' parameter including an example. The description adds context by explaining the premise is a one-paragraph story hint. Baseline 3, plus extra value from the example and clarity.

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: 'Write and produce a Living Panels interactive comic from a one-paragraph premise.' It specifies the verb (create/produce), the resource (comic), and the scope (complete 5-page comic with assets). It differentiates from sibling tools like browse_templates and comic_status.

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 explains when to use the tool: when you have a one-paragraph premise to create a comic. It provides workflow guidance: 'Returns immediately with story summary and reader_url... production takes several minutes — poll comic_status until ready.' While it doesn't explicitly state when not to use, the 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?

Annotations indicate non-read-only and non-destructive. The description adds that it stores a user-owned template and does not publish to the gallery, and hints at idempotency via the schema. No contradictions with annotations.

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 front-load the purpose and key behavioral traits. No extraneous 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?

No output schema, but the description mentions the returned template_id and its compatibility with other tools. For a creation tool with 10 parameters and 100% schema coverage, it is reasonably complete, though error handling or permissions are not discussed.

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 baseline is 3. The description adds context that parameters form a 'structured brief' but does not elaborate on individual parameters beyond the schema. Minimal 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 'Create a private reusable DesignForYou template from a structured brief,' specifying the verb (Create), resource (template), and context. It distinguishes from sibling tools like 'browse_templates' and 'recommend_template'.

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

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

The description explains that the returned template_id works immediately with get_text_fields and generate, and that it does not publish to the anonymous gallery. While it doesn't explicitly prescribe when to use alternatives, it provides clear context for usage.

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

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

The description adds 'Destructive and free' and the refusal conditions (seeded, active references) beyond the annotations' destructiveHint=true. It also mentions deletion of headshot, which is not in annotations.

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 fluff. Front-loaded with the core action and key constraints. 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?

For a simple delete tool with one parameter and no output schema, the description covers the central behavior, constraints, and side effects (deletes headshot, free). No missing critical 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?

The description does not explain the single parameter 'actor_id' (e.g., format, expected value, source). With 0% schema coverage, the description should compensate but fails to add any parameter-specific meaning beyond the schema.

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

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

The description clearly states the tool deletes an unused private actor and headshot, and distinguishes it from sibling tools like create_actor or my_actors by specifying the conditions under which it works.

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 it refuses seeded actors and those referenced by active castings or auditions, providing clear when-not-to-use guidance. However, it does not compare directly to sibling delete tools like delete_audition or delete_casting.

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

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

The description adds significant value beyond annotations by detailing what is removed (media and direction) and what is kept (tombstone for billing, refund, audit). It also states it is 'destructive' which aligns with the destructiveHint annotation, and adds 'free' which is not in annotations. No contradiction.

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 sentences with no fluff. The first sentence conveys the core purpose and constraints, and the second adds necessary detail about retention. Every sentence earns its place.

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

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

For a delete tool with one required parameter and no output schema, the description covers the essential behavioral aspects: destructive nature, scope, and what is retained. It is nearly complete, though it could mention error conditions or permissions for completeness.

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

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

There is only one parameter (audition_id) and schema description coverage is 0%. The parameter name is self-explanatory, but the description does not add explicit details about format or constraints. The meaning is implied by the context, so a 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 removes the authenticated user's media and direction for one ready or refunded-failed audition. It specifies the verb 'remove', the resource (media and direction), and the scope (authenticated user, specific states). This differentiates it from sibling tools like revise_audition or audition_status.

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 indicates the tool is for ready or refunded-failed auditions, providing clear context. However, it does not explicitly state when not to use it or mention alternatives. The destructiveHint annotation reinforces its use case, but the description could be more explicit about 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?

The description adds significant behavioral context beyond annotations, including the 'unused' condition and that it refuses if active auditions exist. It correctly labels the tool as destructive and free, aligning with annotations.

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, with the action and condition front-loaded. Every word is necessary; no filler or redundancy.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers purpose, conditions, and destruction adequately. It provides enough information for an agent to use the tool correctly.

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

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

The schema has one parameter with no description, and the tool description does not provide additional details about the casting_id parameter. However, the context of the tool indicates what the parameter is, making it minimally adequate.

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 deletes an unused authenticated-user casting, with a specific verb and resource. It distinguishes from sibling tools like delete_actor and delete_audition by focusing on castings and the 'unused' condition.

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 tool refuses while active auditions reference it, providing a clear when-not-to-use condition. It lacks explicit mention of alternatives but the context implies auditions must be handled 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?

Annotations indicate readOnlyHint=false and openWorldHint=true, so the tool modifies state and may have side effects. The description adds behavioral context by explaining refinement via session_id and grounding via context_ids, which imply state changes and multi-step workflows, without contradicting annotations.

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 paragraph but is dense and front-loaded with core purpose. It efficiently covers all key aspects without unnecessary words, though it could be better structured with bullet points or separate sentences for readability.

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 has 9 parameters (2 required) and an output schema, the description covers the main workflow, parameter usage, and categories. It does not detail output schema (unnecessary) or error handling, but it is sufficient for an AI agent to select and invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value beyond schema by explaining workflow integration (e.g., getting template_id first) and clarifying how parameters like variants, session_id, and context_ids interact, enhancing understanding.

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 explicitly states the tool generates finished images from a template plus description, specifying the resource (template) and action (generate). It distinguishes from sibling tools like `browse_templates` and `recommend_template` by clarifying this tool is for after template selection.

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

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

The description gives clear context for when to use: after user has selected a template_id, and advises calling `recommend_template` first if not. It explains usage of variants, session_id, context_ids, and mentions it works for all categories. It lacks explicit 'when not to use' but provides strong guidance.

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

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

The description discloses the internal workflow (combining a template with user requirements, using a text LLM to write the final prompt) and key behavioral traits such as preserving character consistency, camera imperfections, ambient audio, and shot structure. These details go beyond the annotations (which only mark openWorldHint) and provide the AI agent with necessary context for invocation and expectation management. No contradictions with annotations.

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 with three sentences, each serving a distinct purpose: stating the function, describing the process, and providing usage scope. No unnecessary information is included, and the key points are 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?

Given the tool's complexity (8 parameters, no output schema, generative nature with potential for unexpected results indicated by openWorldHint), the description lacks details about the output format (e.g., file type, resolution, how the video is returned). It also does not mention potential failure modes or credit consumption. While it covers the core functionality, these omissions reduce completeness.

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 does not elaborate on individual parameters beyond what the schema already provides; it only gives a high-level overview. Therefore, it does not add significant meaning to the parameters.

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

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

The description uses the specific action 'Generate' with the resource 'short realistic character video', explicitly distinguishing this video generation tool from its siblings by detailing the process (template + LLM prompt synthesis) and constraints (3-10 seconds, character/lifestyle clips). This leaves no ambiguity about the tool's core function.

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

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

The description includes a clear usage directive: 'Use this for 3-10 second character/lifestyle clips.' However, it does not explicitly state when not to use it nor suggest alternative tools for different clip types or longer durations, which would further guide the 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?

Annotations indicate readOnlyHint=false (write) and destructiveHint=false. Description adds that it uses actor headshots as references and returns a stored image_url, and defaults to Gemini. No contradictions. Adds context about provider routing and actor count limits (max 4), but could mention response format or error 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 concise sentences cover core purpose and key usage pattern, with a third for provider default. Front-loaded with essential information, 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 tool with 9 parameters and no output schema, the description adequately covers main workflow: generating frames, using continuity, selecting providers. Missing details about output format (image_url semantics) and error handling, but sufficient for typical 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?

Schema description coverage is 100%, providing baseline 3. Description adds extra meaning: explains continuity_scene_frame_id usage ('preserves set topology...'), actor_ids should be only visible actors, and provider limits (Grok supports up to 3 actors). This goes beyond 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 verb 'generate', the resource 'actor-grounded narrative first frame', and the required inputs (actor_ids, location, wardrobe, pose, composition). It distinguishes from sibling animation tools by specifying its purpose as generating a static frame before animation.

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 guidance for multi-shot continuity (generate wide reference first, then pass continuity_scene_frame_id) and instructs to use this tool before animation when a headshot is insufficient. It also advises on provider selection. Lacks explicit 'when not to use' but offers strong contextual cues.

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

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

Annotations declare readOnlyHint=true, indicating safe read. The description adds that it is 'Free to call' and returns specific data fields, providing useful behavioral context beyond annotations.

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 wasted words. The main action and outputs are front-loaded, and the extra note about being free is 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?

With no parameters and no output schema, the description sufficiently explains the return values (credit balance, usage, subscription status), making it complete for a simple read 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?

The tool has zero parameters, so the description does not need to add parameter info. The baseline of 4 applies, and the description provides context on what is returned.

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 returns credit balance, usage, and Stripe subscription status. It uses specific nouns and verbs, and is distinct from sibling tools which are about templates and generation.

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 context by stating it returns authenticated user's credit info. It does not explicitly mention when not to use or compare to alternatives, but the sibling tools are unrelated, so guidance is adequate.

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

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

Annotations declare readOnlyHint true, and the description's 'List' action aligns perfectly. Additionally, it adds that the tool is free (no cost), which is beyond annotations and provides useful 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?

Two sentences: first states purpose, second provides usage guidance. No redundant information, front-loaded, and every sentence serves a distinct informative purpose.

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 what the tool returns (editable text fields with current values), its scope (template-specific), and prerequisites (template chosen). 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%, so the description does not need to elaborate on parameters. The description simply reinforces the usage context without adding new semantic detail beyond the schema.

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

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

The description uses a specific verb ('List'), names the resource ('template's editable text fields'), includes illustrative examples ('headline, subhead, CTA'), and distinguishes from siblings like 'edit_text' and 'generate' by implication (listing vs. modifying).

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 ('right after a template is chosen and BEFORE generate'), when not to rely on it ('instead of relying on a freeform description'), and notes it's free.

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 fully discloses behavior: ordering ('newest first'), pagination ('bounded offset pagination'), content exclusion ('never returns internal identity prompts or visual descriptions'), and cost ('Free'). This is comprehensive.

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 with no waste. The first sentence immediately communicates the core purpose. Every phrase ('Free', 'bounded offset pagination', content exclusions) adds necessary 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?

Given the simple parameters (2, fully described in schema) and no output schema needed for a list, the description covers ordering, pagination boundaries, and content exclusions. It is complete for this tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining 'Supports bounded offset pagination' linking to limit/offset, and 'newest first' as ordering not in schema. This provides context beyond parameter names.

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 'the authenticated user's private reusable LetMeActForYou actors,' specifying both the resource type and ownership. It distinguishes from sibling tools like browse_templates (templates) and create_actor (creation) by focusing on user-specific private resources.

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

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

The description implies usage when listing the user's private actors, and notes it is 'Free' and never returns certain content. It does not explicitly state when NOT to use it or mention alternative tools, but the context of siblings provides 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, so description carries full burden. It discloses read-only behavior ('list'), ordering ('newest first'), pagination, and optional filtering. No destructive actions mentioned, which is appropriate.

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 with no wasted words. Front-loaded with the core action and scoping. Efficient and clear.

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 return behavior (list, newest first), pagination, and filter. It doesn't detail individual fields, but that is acceptable given the tool's simplicity.

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 100% of parameters, baseline 3. Description adds mention of 'bounded offset pagination' and 'optional status filter', aligning with parameters but not adding significant new meaning.

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 'List only the authenticated user's LetMeActForYou audition history' with a specific verb and resource, distinguishing it from sibling tools like 'audition' which likely handles single auditions.

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 context: 'Free' and supports pagination and status filter. Does not explicitly state when to use vs alternatives, but the scope is clear enough for the agent.

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

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

Annotations already declare readOnlyHint=true, so no mutation. Description adds auto-detection and ranking details. No contradictions. Context about recommendation return is provided.

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

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

Two sentences: first states core function, second provides procedural guidance and constraint. 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?

With output schema existing, description covers what the tool does, how to use it, and constraints. Sibling tools are distinct. Complete for this type of recommendation 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 schema already describes each parameter. Description adds usage pattern ('Describe what you need') and notes auto-detection of category, which adds value beyond 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?

Clearly states the verb 'Recommend' and resource 'templates'. Distinguishes from sibling tools like browse_templates and generate. The auto-detection and ranking behavior are described.

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 ('Describe what you need') and when not to (do not call generate unless user explicitly names template_id). Tells agent to return recommendations for user 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?

The description adds behavioral details beyond annotations: 'Stores bounded triage metadata without copying prompts, media URLs, billing data, or account identity.' This clearly explains what data is stored and what is not, and it does not contradict annotations.

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 no wasted words; the first covers purpose and scope, the second adds behavioral transparency.

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?

While the description covers purpose and behavioral intent, it lacks details on parameter meanings and potential consequences of reporting, which would be useful for an agent. However, it is adequate given the presence of annotations.

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 0%, and the description adds minimal parameter insight beyond implying target_type and target_id from the purpose. It does not explain the 'reason' enum values or the 'details' field.

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 'report' and specifies the resources: 'visible LetMeActForYou actor or an audition owned by the authenticated user.' This distinguishes it from siblings like delete_actor or delete_audition.

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 the tool (reporting abuse) but does not explicitly state when not to use or suggest 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?

Annotations indicate write operation and non-destructive nature. The description adds detail on inheritance behavior and preservation of parent IDs and director note, which is valuable beyond annotations. Could mention permissions or side effects, but acceptable.

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, information-dense sentence. No wasted words; front-loaded with core action and inheritance details. Perfectly 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?

Given 5 parameters, no output schema, and moderately complex inheritance logic, the description covers key behaviors. Lacks error conditions or prerequisites, but for a creation tool the description is reasonably 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?

With 0% schema description coverage, the description compensates by explaining that optional parameters (cue, emotion, line) serve as overrides inheriting from parent. Required parameters (parent_audition_id, direction_notes) are mentioned but not their semantics beyond necessity.

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 'create' and resource 'child take from an existing audition'. It differentiates from sibling tools like 'audition' by specifying it is a child take creation, not a listing or status check.

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 needing to create a new take based on an existing one, but it does not explicitly state when to use this tool versus alternatives like 'audition' or 'generate'. No guidance on prerequisites or exclusions.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true), the description discloses cost structure, the full pipeline (generate, crop, chroma-key, validate, manifest), and optional hi-res re-render with additional billing. No contradictions with annotations.

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

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

The description is three sentences, front-loaded with the core purpose. It is well-structured, moving from main action to cost to optional features. While not overly verbose, it could be slightly more concise by merging the optional quality explanation into a single sentence.

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 (8 parameters, nested objects, output schema), the description covers the essential pipeline, cost, and key optional behavior. The output manifest is not detailed but an output schema likely handles that. It lacks guidance on parameter interplay (e.g., when to use hi_res_model) but is adequate for a generative tool.

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

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

Schema description coverage is low (25%). The description adds meaningful context for only two parameters (quality.hi_res_cells and hi_res_model) regarding purpose and cost. For the four required parameters (character, style, sheet, cells), the description provides no additional semantics beyond their names, relying on the schema which lacks descriptions for many fields.

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 function: generating a fixed-grid VN character sprite sheet, cropping, chroma-key removal, validation, and returning a manifest. The verb 'generate' and resource 'sprite sheet' are specific, and the title matches. It distinguishes from siblings like 'generate' or 'generate_character_video' by being explicitly for sprite sheets.

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 context (base cost, optional hi-res pass) but does not explicitly state when to use this tool versus alternatives like 'generate' or 'audition'. There is no mention of exclusions or prerequisites, leaving the agent to infer usage from the name.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=false. The description adds behavioral context: it returns a fixed payload, is no-cost, and is for debugging only, beyond what annotations alone convey.

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 front-load the purpose and then provide usage guidance. Every sentence 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?

For a simple diagnostic tool with one optional parameter and an output schema, the description covers purpose, usage, and limitations completely, leaving no ambiguity for the agent.

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 parameter 'mode' has a description explaining it selects the widget payload shape. Schema description coverage is 100%, so description does not need to add more; 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 explicitly states the tool returns a 'fixed, no-cost DesignForYou widget payload for ChatGPT Apps debugging', using a specific verb and resource, and clearly distinguishes itself from sibling generation tools by stating what it does not do.

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 says 'Use this only to verify the template gallery/result iframe renders correctly' and explicitly excludes generation, LLM use, and credit charges, providing clear when-to-use and when-not-to-use guidance.

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