designforyou

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

The description adds a useful behavioral detail beyond the annotations: 'The result is normalized to the requested source duration.' This clarifies post-processing behavior. Annotations already indicate the tool is non-read-only and non-destructive, and the description does not contradict them, though it does not disclose output format or async 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, front-loaded with the action and model name. No redundant or filler content; every word 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?

The description covers the core function and a key behavioral trait, and annotations cover the safety profile. However, with no output schema, the description does not explain what the generated result looks like (e.g., video URL or file) or whether the operation is asynchronous, leaving meaningful gaps for a generation tool with 7 parameters.

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%, with key parameters like prompt, line, image_url, and image_data_url already described in the schema. The description adds some context by mentioning 'one reference frame' and 'requested source duration', but it does little to clarify model, aspect_ratio, or other undocumented semantics 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 starts with 'Generate a short image-to-video take with xAI Grok Imagine Video from one reference frame', which specifies a clear verb, resource, and scope. It distinguishes this tool from siblings like animate_reference_image and animate_reference_video by naming the xAI Grok Imagine Video model.

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: use this when you want to create an image-to-video animation with Grok from a reference frame. However, it provides no explicit guidance on when to prefer this tool over the sibling animate tools, nor does it state any exclusions or alternatives.

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 the annotations (readOnlyHint=false, destructiveHint=false), the description adds little behavioral disclosure. It does not mention output format, side effects, rate limits, or the batch_approved requirement, and it does not explain what happens after generation. This is a significant gap for a tool with 8 parameters and no output schema.

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, front-loaded with the core purpose and a terse input-guidance note. Every sentence earns its place, 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 8 parameters, no output schema, and a large set of similar sibling tools, the description is incomplete. It does not explain what the tool returns, how model selection works, or how this tool differs from animate_reference_video and animate_reference_grok_video, and it omits the batch_approved behavior.

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 adds context for image_url/image_data_url by saying HTTPS/data URLs are used when source style and composition need to anchor the shot, complementing the schema. However, it does not cover model, duration, or aspect_ratio, which have no schema descriptions, so with 63% schema coverage it only partially compensates.

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

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

The description states a clear action ('Generate a short vertical image-to-video take from one supplied reference frame') with a specific verb and resource. It does not explicitly distinguish this tool from similarly named siblings like animate_reference_video, so it falls short of full 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 phrase 'Use an HTTPS artifact URL or a data URL when exact source style and composition need to anchor the shot' implies when the tool is appropriate, but it does not compare this tool to alternatives or state when not to use it. There is no explicit guidance for choosing among the many sibling generation 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=false, openWorldHint=true, and destructiveHint=false, so the description need not restate those. It adds that the tool preserves source shot attributes, but does not disclose processing behavior, input requirements, or rate limits. No contradiction 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 compact sentences, front-loaded with the verb and object, and every phrase earns its place. There is no redundant or vague 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?

With no output schema and 8 parameters, the description is too thin. It does not explain how the source clip is supplied (via video_url or video_data_url), does not mention duration, aspect ratio, or the batch_approved requirement, and gives no sense of the output format. These are substantial gaps 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 description coverage is 63%, with descriptions for prompt, line, video_url, batch_approved, and video_data_url. However, the description itself adds no parameter-level context and does not compensate for the undocumented parameters model, duration, and aspect_ratio. This leaves gaps for an 8-parameter tool.

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 video take from a supplied source clip, with a specific verb and resource. It also specifies what is preserved (actors, style, wardrobe, camera, action), which distinguishes it from the sibling still-frame reference tool, though without naming it.

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 a use case: when you have a source clip and want to preserve its attributes. The comparison to a still-frame reference gives a hint, but there is no explicit when-to-use guidance or alternatives named, and no mention of when not to use this tool.

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 this is a mutating but non-destructive operation. The description adds that the tool normalizes multiple sources into a 9:16 MP4, but it does not disclose potential side effects like overwriting output files, downloading HTTPS URLs, or failure behavior. This is acceptable but not rich.

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-loaded with the action and resource. No fluff or repetition of schema details; 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?

Despite having 9 parameters and no output schema, the description captures the essential workflow ('missing composition step for multi-take LetMeActForYou stories') and the output format. Parameter-level details are left to the schema, which covers most optional behaviors, so this is sufficient for high-level tool 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 has descriptions for 6 of 9 parameters (67% coverage). The description adds the notion of 'ordered' segments and 'generated-artifact URLs' and identifies the output as 'normalized 9:16 MP4,' but it does not explain individual parameters in depth. Moderate schema coverage keeps this at baseline.

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 ('Assemble') and resource ('ordered local video segments or HTTPS generated-artifact URLs') and clearly states the output ('one normalized 9:16 MP4'). It also distinguishes this from sibling generation tools by calling it 'the missing composition step for multi-take LetMeActForYou stories.'

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

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

The description clearly indicates when to use this tool: after generating multiple takes, when you need to compose/normalize them into a final MP4. It does not name alternative tools or explicitly list exclusions, but the workflow context is strong enough to guide 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?

Annotations already indicate this is a non-read action and non-destructive, but the description adds key behavioral details: the tool is billed, and it is asynchronous because it returns an audition_id immediately and requires polling of audition_status until ready. These are important traits not captured by the annotations alone, enhancing transparency beyond the structured data.

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 declarative sentences, each with a distinct purpose: define the action, explain the async flow and return artifacts, and indicate where the actor_id comes from. It is front-loaded with the primary verb and noun, contains no filler, and every sentence earns its place by contributing essential operational or prerequisite 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?

Despite having no output schema, the description explicitly discloses that the tool returns an audition_id immediately and later provides a shareable video_url, covering the return value lifecycle. It also flags billing, which is critical for a paid action. While it doesn't mention failure modes or alternate casting_id paths, those are sufficiently explained in the schema, so the description covers the core transaction workflow.

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 100% description coverage, so the baseline is 3. The tool description itself only highlights 'cue' and 'actor_id' source, without adding new meaning to parameters such as casting_id, direction_notes, or batch_approved. Since the schema already documents all parameters sufficiently, the description's marginal contribution to parameter understanding is minimal, consistent with a 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 opens with the specific verb 'Start' and resource 'casting audition', and elaborates with a concrete summary: the actor performs a cue in a short vertical video. It distinguishes this from sibling tools like audition_status (which polls status) and revise_audition (which modifies) by focusing on the initiation action and the immediate billing implication.

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 begin an audition. It includes operational workflow guidance ('Returns audition_id immediately; poll audition_status...') and points to a prerequisite ('Get actor_id from casting_roster'), but it does not explicitly enumerate exclusion criteria or compare with alternative audit tools beyond the workflow implication. That fits 'clear context, no 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, covering safety. The description adds useful specifics: status values, the video_url field when ready, and that it's free to call. This goes beyond the annotations without contradicting them.

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

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

A single, well-structured sentence that front-loads the purpose and includes key return details. No redundant words or 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?

For a simple read-only status tool with one parameter and no output schema, the description sufficiently covers behavior, return values, and usage context. No significant 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?

The schema already fully describes audition_id as 'Audition id returned by audition' (100% coverage). The description's mention of 'started with audition' aligns with this but adds no additional parameter semantics beyond what the schema states.

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

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

Description clearly states the tool checks an audition's status (rendering/ready/failed) and provides the video_url when ready. This distinguishes it from sibling tools like 'audition' (which starts the process) and 'delete_audition' or 'revise_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 phrase 'started with audition' clarifies that the tool applies to auditions initiated via the 'audition' tool, and 'Free to call' suggests no cost concern. It doesn't explicitly name alternatives but gives clear contextual timing for 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?

Annotations already declare readOnlyHint=true, so the agent knows it's a safe read operation. The description adds value by stating the return format: 'Returns template IDs, names, and previews.' However, it does not disclose other behavioral nuances like pagination, rate limits, or how previews are represented. This is adequate but not rich, so a mid-range score 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?

The description is two sentences long and front-loaded with the core purpose. The first sentence establishes the action, the second covers filtering and results. Every word serves a purpose; there is no fluff or redundancy. This is a model of 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?

Given the tool's simplicity (2 optional parameters, read-only, output schema present), the description provides sufficient context for an agent to decide when to invoke it. It covers purpose, optional filters, and return content. It could mention subcategory filtering explicitly, but the schema fills that gap. The description is complete enough for this low-complexity 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 input schema already provides descriptions for both parameters (category and subcategory) with examples, achieving 100% schema coverage. The description adds a minor detail by listing an additional category example 'living-panels' not present in the schema, but it does not explain subcategory usage. Since the schema fully documents the parameters, 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's purpose: 'Browse the DesignForYou template catalog.' It specifies the verb 'browse' and the resource 'template catalog', and distinguishes itself from sibling tools like create_template and recommend_template by focusing on browsing existing templates. It also mentions optional filtering and return values, making the scope 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 clear context for when to use this tool: browsing the template catalog with optional category/subcategory filters. It does not explicitly mention alternatives or exclusion criteria, but the purpose is so distinct from siblings (e.g., create_template, recommend_template) that the intended usage is evident. Missing explicit 'when not to use' guidance prevents a perfect score.

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 discloses that the operation returns a casting_id that preserves identity and provenance across takes, and restricts input to seeded/private actors. This adds behavioral context about persistence 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?

Single sentence with a front-loaded verb, clear object, and return value. No filler or redundant restatement of the tool name.

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 six-parameter mutation with no output schema, the description gives the core action and return value but omits preconditions, repeated-cast behavior, and meaning of optional fields like notes/source_url. Sibling delete_casting hints at lifecycle but the description itself leaves these 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 only 17% (only character_description has a description). The description does not explain notes, source_url, or the relationship/semantics of actor_id/story_id beyond 'seeded or private actor' and 'one story character', so it fails to compensate for the low 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?

Description uses specific verb 'Bind' with clear resources: 'seeded or private actor' to 'one story character'. It distinguishes from sibling tools like casting_roster (listing), delete_casting (removal), and audition by describing the act of assigning an actor to a character and returning a casting_id.

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

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

The phrase 'Bind a seeded or private actor to one story character' implies the tool should be used when assigning such an actor to a character, and 'across takes' suggests persistence. However, no explicit when-to-use/not-use guidance or alternatives are mentioned.

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, but the description adds critical behavioral context: this is a public catalog with seeded actors, excludes user private actors, and returns specific fields (headshots, type, bio). This goes beyond the annotations and clarifies the tool's data scope and contents.

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 core purpose, then provide exclusion criteria and a recommended workflow. Every sentence earns its place, with no fluff or repetition of schema/annotation data.

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 read-only listing tool, the description fully explains what the agent gets (public roster with headshots, type, bio), who it belongs to (public, no private actors), and how to proceed (call audition with actor_id). Even without an output schema, the expected return fields and usage flow are clear.

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

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

The input schema has one optional parameter that is an empty object with no properties, effectively meaning no meaningful parameters. The description adds no parameter details, but none are needed since the schema fully defines the empty input. Per the rubric, 0 meaningful params baseline is 4, so this 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 starts with a specific verb+resource+scope: 'List only the public seeded LetMeActForYou casting roster with headshots, type, and bio.' It clearly distinguishes this from related tools by explicitly stating it never includes private actors, and points to my_actors for that, giving it unique purpose among siblings.

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

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

Provides explicit usage guidance: 'Call this first, show the user the seed actors, then call audition with the chosen actor_id.' It also names the alternative tool for private actors ('authenticated users can retrieve those with my_actors'), telling the agent when not to use this tool.

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, covering the safe read nature. The description adds useful context about the brief contents and intended workflow, which goes beyond the annotations. No contradictions or hidden behaviors are apparent. Minor gaps like response format details are acceptable for a simple getter.

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, front-loaded with the action and resource, then provides usage context. Every sentence contributes meaning. The term 'no-server-LLM' is slightly terse but not wasteful.

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

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

For a simple getter with one parameter, the description is complete. It lists the return contents (PanelScript instructions, schema, unit templates, success criteria) and gives usage context. Annotations cover the safety profile. No output schema exists, but the description sufficiently explains what is returned.

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

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

Schema description coverage is 100% (single parameter 'premise' with a clear description). The main description does not add additional parameter semantics. Baseline 3 is appropriate because the schema fully documents the parameter.

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 'Return' and names the resource 'no-server-LLM Living Panels authoring brief' with enumerated contents (PanelScript instructions, schema, unit templates, success criteria). It clearly distinguishes from sibling tools by focusing on the authoring brief and referencing the follow-up tool comic_submit_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?

The description explicitly states when to use the tool: when the MCP client will do creative direction with its own model. It also connects to the next step (comic_submit_design). However, it does not explicitly say when not to use it or mention alternative tools like comic_revision_brief, so it falls short of a full 5.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds valuable behavioral context by enumerating the returned data (stale-write hash, dirty-node contract) and framing the tool as a step in the revision workflow, complementing the read-only annotation without contradicting it.

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

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

The description is two sentences with the return payload front-loaded and the usage context clearly stated. Every word is purposeful; there is no redundancy or unnecessary detail.

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

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

This is a simple read-only tool with one parameter, and the description lists its output components (Story JSON, stale-write hash, allowed patch paths, dirty-node contract) while specifying the workflow position. Given the lack of an output schema, the description provides enough information for an agent to understand the tool's role and invoke it correctly.

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

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

The input schema fully covers the single parameter comic_id with a clear description ('Comic id to revise.'). The tool description adds no additional parameter-level meaning beyond what the schema already provides, so the baseline score of 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 uses a specific verb ('Return') and resource ('current Story JSON, stale-write hash, allowed patch paths, and dirty-node contract'), clearly defining the tool's scope. It also distinguishes this from the sibling comic_submit_revision by explicitly positioning it as the pre-submission brief for client-authored edits.

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 when to use the tool ('when the client will decide the edit with its own model') and directs the agent to the follow-up call ('then call comic_submit_revision'). This provides clear contextual guidance, though it does not enumerate when not to use it or name 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?

Annotations already declare readOnlyHint=true, so the description's main contribution is the 'Free to call' note and the semantic meaning of the ready flag (whole comic live at reader_url). This adds useful behavioral context beyond the structured annotations without contradicting them.

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

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

The description is a single, information-dense sentence. It front-loads the purpose, then details the metrics and the ready flag, with no 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 one-parameter tool with no output schema, the description fully explains what the tool returns (panels, motion clips, voice lines counts, ready flag) and the significance of ready=true. Combined with strong annotations, this is a complete picture for an 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 coverage is 100%, with the parameter comic_id described as 'Comic id returned by create_comic'. The description reuses this context but adds no new parameter-specific details, so it meets the baseline without exceeding it.

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: checking asset-production progress for a comic. It specifies the resource (comic created with create_comic) and the exact metrics (panels, motion clips, voice lines done vs total, ready flag), distinguishing it from sibling tools like 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 provides clear context for when to use the tool—after creating a comic with create_comic—and adds the 'Free to call' guideline. It does not explicitly mention alternatives or when-not-to-use, but the context is sufficient for a status-checking tool.

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, the description discloses that the tool validates, saves, generates character sheets, panel/unit art, motion clips, voice-over, and assembles the public reader. This conveys significant side effects and mutation, consistent with readOnlyHint=false and destructiveHint=false. It does not mention costs or return values, but annotations already cover the safety profile.

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

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

The description is a single, well-structured sentence that front-loads the purpose and then details the pipeline. Every clause adds actionable context, with 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?

The description covers the input and processing pipeline comprehensively, but omits what the function returns or how the agent should follow up. Since there is no output schema, this return-value gap is a notable omission, though sibling tools like comic_status may imply monitoring.

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 all five parameters well-described in the input schema. The description does not add param-specific semantics beyond the overall workflow, so the 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 accepts a client-authored Living Panels Story JSON and starts artifact production, including the specific pipeline (validate, save, generate, assemble). It distinguishes itself from sibling tools like comic_submit_revision and create_comic by emphasizing client-directed input and avoiding the server story LLM.

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: when the client authors the story directly, without relying on a server LLM. It implies a workflow but does not explicitly name alternatives or exclusions, making it helpful but not fully prescriptive.

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 a key behavioral trait: it does not invoke a server revision LLM, and it regenerates only inferred dirty producer nodes (e.g., panel:<id>, motion:<id>, tts:<bubble_id>). This adds meaningful context beyond the readOnlyHint=false and destructiveHint=false annotations, which are consistent with the described write-and-regenerate 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, front-loaded with the primary action, and every clause contributes to understanding purpose and behavior. No redundancy or 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?

The description, combined with a 100% schema-covered parameter list and clear annotations, is sufficient for an agent to select and invoke the tool. It could mention return values or status, but since there is no output schema, the description covers the core behavior adequately without major 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 100%, so the baseline is 3. The description adds value by giving concrete examples of dirty producer nodes and explaining that targeted changes regenerate only those nodes, reinforcing the distinction between the 'changes' and 'story' parameters. This goes beyond the schema alone.

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 ('Apply') and names the exact resource ('client-authored Living Panels revision'), while the qualifier 'without using a server revision LLM' distinguishes it from server-driven revision workflows. This clearly separates it from siblings like comic_revision_brief or comic_submit_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?

The description gives clear context: use this tool when applying a client-authored revision, not a server LLM revision. It also notes that targeted changes are the preferred path for small edits. It doesn't explicitly name alternative tools, but the guidance is sufficient for an agent to decide when to invoke 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the disclosure adds significant behavioral context: generation of headshot, S3 storage, draft privacy, clip prioritization of performance_reference_url, and default template quality. This exceeds what annotations provide, though it doesn't cover all possible side effects like 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 four sentences, each delivering distinct information: core purpose, draft/public workflow, performance reference guidance, and template/visual description guidance. It is front-loaded with the main purpose and contains zero 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?

The description covers the creation flow, return value, draft state, publishing path, and key parameter guidance. It doesn't explain every minor parameter (bio, emoji, actor_type) but these are likely self-explanatory. Overall, it provides sufficient context for an agent to understand the tool's role and 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 description adds valuable meaning to visual_description (stable physical identity, not performance direction) and performance_reference_url (full-body standing, prioritized). However, with schema coverage at only 43%, parameters like bio, emoji, and actor_type are left undocumented in both the schema and description, so the description doesn't fully compensate for the gap.

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 LetMeActForYou actor draft, generates a casting headshot, stores it on S3, and returns actor_id for cast_character or audition. This specific verb+resource+outcome clearly distinguishes it from siblings like publish_actor and cast_character.

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 the draft workflow, noting that drafts never appear in the public feed and that publish_actor is used when the actor is ready. It also gives guidance on providing performance_reference_url when available. However, it doesn't explicitly name alternative creation tools or directly state 'use this instead of X', but 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?

The description goes far beyond annotations by revealing asynchronous behavior: 'starts generating every asset in the background,' 'Returns immediately,' and 'Production takes several minutes — poll comic_status.' It also discloses the output (story summary, reader_url) and the need for polling. No contradiction with annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false).

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 four sentences, front-loaded with the main verb and resource, and every sentence adds unique value: scope, background generation, immediate return, and follow-up polling. No fluff 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?

Despite no output schema, the description gives a complete picture of the tool's behavior and result: what is created, what is returned, how long it takes, and how to check status. It even mentions details like '~13 panels of art with character consistency' and 'per-line voice-over,' making it fully self-contained for a complex 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% for the single parameter 'premise,' and the schema already explains it as 'The story premise, one paragraph is plenty.' The description only repeats 'one-paragraph premise' without adding new meaning about parameter formatting or constraints. Baseline 3 is appropriate since the schema handles the semantics.

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: 'Write and produce a Living Panels interactive comic from a one-paragraph premise.' It details the full scope (5-page comic, panels, dialogue, motion, voice casting) and distinguishes it from lower-level tools in the sibling list (e.g., cast_character, generate_scene_frame) by emphasizing it's a single all-in-one call.

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 when to use the tool (for creating a full comic from a premise) and provides a workflow ('Returns immediately... poll comic_status until ready... share the reader_url'). However, it does not explicitly contrast with alternatives like comic_revision_brief or comic_design_brief, so it lacks a clear 'when-not-to-use' statement.

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 mark this as non-read-only and non-destructive; the description adds meaningful context: it stores a user-owned template in the canonical catalog, does not publish to the anonymous gallery, and the returned id is immediately usable with other tools. This goes beyond the annotations by clarifying side effects and integration 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, 46 words, with the action and resource front-loaded. Every clause adds value—what it creates, how the result is used, where it is stored, and what it does not do.

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

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

The tool has 10 parameters and no output schema, but the description covers the essential return behavior (template_id) and its integration with get_text_fields and generate. It does not enumerate all parameters, but the schema already handles that. The description is sufficient for the agent to select and invoke 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%, so the baseline is 3. The description adds little parameter-specific detail beyond calling it a 'structured brief', but the schema already thoroughly documents each parameter, so no significant gap exists.

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 specific verb ('Create') and resource ('private reusable DesignForYou template') and clearly states it derives from a structured brief. It distinguishes itself from siblings like browse_templates and generate by emphasizing privacy, reusability, and catalog storage.

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 with get_text_fields and generate, and explicitly states it does not publish to the anonymous gallery, giving the agent a clear sense of when this tool is appropriate. It lacks an explicit alternative name, so it doesn't fully earn a 5, but the context is strong.

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 mark the tool as destructive (destructiveHint=true), but the description adds valuable behavioral details beyond that: it also deletes the headshot, refuses certain actor types, and notes it is 'free'. These are non-obvious traits that help the agent anticipate outcomes.

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, front-loaded with the action and followed by constraints. Every word earns its place, and it avoids redundancy with the 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 simple one-parameter destructive tool, the description is complete: it explains the scope (unused private actor), the side effect (headshot deletion), and the refusal conditions. No output schema exists, but the tool's behavior is sufficiently covered.

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 schema description coverage at 0%, the description carries the burden for explaining actor_id. It implicitly defines it as the identifier of the actor to delete by saying 'Delete an unused private actor...', but does not explicitly label the parameter or elaborate on its constraints beyond what the schema already provides. This is adequate but not rich.

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

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

The description clearly states a specific verb ('Delete') with a specific resource ('an unused private actor and headshot'). It also distinguishes the scope (private, unused) and mentions refusal conditions, which differentiates it from sibling tools like create_actor or my_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?

The description provides clear context for when to use the tool: it targets unused private actors and explains it will refuse seeded actors or those referenced by active castings/auditions. This gives implicit guidance on when the tool is appropriate, though it doesn't explicitly name alternative tools for other 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?

Discloses that deletion is permanent, that a minimal tombstone is retained for billing and audit, and that the operation is destructive and free. This goes beyond the destructiveHint annotation by explaining the tombstone side effect and the scope (authenticated user's own media), enhancing transparency 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?

Two sentences with no fluff; each clause adds relevant information: what is deleted, when it applies, what is kept, and the cost implication. Highly efficient and front-loaded, with no redundant phrasing.

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 destructive tool with one parameter and no output schema, the description covers core behavior, eligible states, and side effects. It lacks explicit return value documentation, but without an output schema this is not critical. It is sufficiently complete for an agent to invoke correctly.

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

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

The input schema has one required parameter, audition_id, with no schema description (0% coverage). The description references 'one ... audition' but does not explicitly state that audition_id identifies the target, nor does it mention any format or validation expectations. The parameter name is self-explanatory, but the description fails to compensate for the lack of schema documentation.

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 permanently removes the authenticated user's media and direction for a specific audition, with eligibility limited to ready or refunded-failed states. This distinguishes it from sibling tools like revise_audition or delete_actor by specifying the action, target, and conditions.

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 that only ready or refunded-failed auditions are eligible, which implicitly excludes other states. It does not explicitly name alternative tools, but the state restriction serves as a usage boundary and gives the agent enough guidance to select this tool appropriately.

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 the annotations (destructiveHint=true), the description adds 'free' (no cost) and the refusal behavior when active auditions reference it. These are useful behavioral traits not captured in the structured data.

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

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

Three short sentences, each adding meaningful information. The description is front-loaded with the core action and avoids any 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?

For a one-parameter delete tool without an output schema, the description covers the essential purpose, a condition, and a cost note. It does not mention return values, but that is unnecessary given the tool's simplicity and the absence of an 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?

With 0% schema description coverage, the description should compensate, but it only refers to 'casting' without explicitly detailing the casting_id parameter. The schema already provides the title 'Casting Id' and length constraints, so the description adds minimal extra 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 verb ('Delete') and resource ('casting'), with a specific scope ('unused authenticated-user casting'). It also distinguishes itself from sibling tools like delete_actor and delete_audition by focusing on castings and includes a key condition ('Refuses while active auditions reference it').

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 an explicit when-not condition: the tool refuses to delete while active auditions reference the casting. This tells the agent when the tool will fail and implies it should only be used for unused castings, serving as clear usage 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 adds meaningful behavioral context beyond the annotations: it reveals the operation is paid (5 credits), starts from the source's final frame, preserves eligible references, and returns lineage metadata. Since annotations only provide readOnlyHint=false and destructiveHint=false, the description enriches the agent's understanding of side effects and output, though it does not mention any potential failure modes 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 three sentences, tightly packed with essential information: purpose, constraints, cost, and return value. There is no fluff or redundant repetition of schema fields, 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?

Even without an output schema, the description clearly explains the return value (new queued request ID and lineage metadata) and includes necessary context like cost, duration restrictions, and source ownership. This makes the tool fully understandable for an agent to invoke correctly, given its moderate 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%, and the description reiterates key constraints like duration values (5, 10, or 15 seconds) and source ownership, which are already in the schema. It does not significantly enhance parameter meaning beyond what the schema provides, 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's purpose: 'Queue one paid MiniMax H3 continuation from a completed video owned by the authenticated caller.' This identifies the specific verb (queue), resource (MiniMax H3 continuation), and key constraint (from a completed video), distinguishing it from siblings like queue_minimax_h3_videos that likely create new videos.

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: it requires a 'completed video owned by the authenticated caller' and specifies the continuation starts from the final frame. It also implies a paid operation with 5 credits and limited durations. However, it does not explicitly name alternatives or exclusion cases (e.g., 'do not use for new videos'), so it falls short of an explicit when-to-use versus sibling guidance.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false, openWorldHint=true), so the description carries the burden. It discloses key behaviors: generating images, supporting variants, refining via session_id, grounding via context_ids, and the smart prompt-merge step with skip_prompt_merge. It does not contradict annotations and adds significant context, though it omits potential side effects or failure modes, keeping it from a 5.

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

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

The description is four sentences long, front-loaded with the main purpose, and includes actionable usage guidance without redundancy. Every sentence contributes meaningful information about template acquisition, use cases, and parameter purposes, making it highly 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?

Given the tool's complexity (9 parameters, output schema present), the description covers the core workflow, template acquisition, refinement, grounding, and supported categories. It does not need to explain return values thanks to the output schema, but it could be slightly more complete by mentioning exclusions (e.g., when to use video tools instead), though the sibling list partially covers this.

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?

Since schema description coverage is 100%, the baseline is 3. The description adds value by explaining when to use variants (multi-image output), session_id (refine prior result), and context_ids (character consistency), which goes beyond individual schema descriptions. However, it does not elaborate on less-central parameters like model, edit_tier, or context_labels, which remain schema-dependent.

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 that the tool generates one or more finished images from a template plus a description, and specifies the source of template_id (recommend_template or browse_templates). It distinguishes itself from siblings by outlining the exact workflow and supported categories (Instagram, logo, app-store, Visual Novel backgrounds/sprites, CG illustrations).

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

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

The description explicitly tells the agent when to use this tool: after the user has selected or explicitly supplied a template_id, and instructs to call recommend_template first if not. It also mentions using session_id for refinement and context_ids for grounding, providing clear usage context and an alternative tool.

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 reveals internal behavior: it passes a template and requirements to a text LLM to create a final video prompt while preserving specific characteristics (character consistency, camera imperfections, ambient audio, shot structure), then generates the video with Gemini Omni Flash. This goes beyond the annotations (which only indicate non-read-only, open-world) by explaining the generation pipeline and constraints.

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-loads the core purpose, includes the process and a usage recommendation, and contains no fluff or repetition of schema 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?

Given the tool's complexity (9 parameters, no output schema), the description covers the key context: the generation pipeline, the preservation of video qualities, and the 3-10 second use case. It does not explicitly mention the return format or the batch_approved parameter, but these are covered in the schema, and the description provides enough high-level context for an agent to use it 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?

The input schema has 100% coverage, so the baseline is 3. The description mentions 'structured requirements' and the preservation of certain features, but it does not add specific parameter-level details beyond what the schema already provides. The schema's parameter descriptions are already self-explanatory, so the description doesn't compensate for any gaps (there are none).

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 realistic character video from structured requirements.' It distinguishes itself from sibling tools by specifying that it uses a text LLM to synthesize a fresh prompt from a reusable template and generates a Gemini Omni Flash video, which is unique among the listed video-generation 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 a direct usage guideline: 'Use this for 3-10 second character/lifestyle clips.' This indicates the intended use case, and the mention of 'structured requirements' implies when to use it over more reference-based siblings like animate_reference_video. However, it does not explicitly name alternatives or state when not to use this tool.

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 valuable behavior beyond the annotations by explaining the internal handling: MiniMax H3 receives byte-identical first/last frames, and the Grok CLI path replaces the frames with the source image after generation. This non-obvious nuance is not available from the structured metadata.

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 just two sentences, with the purpose front-loaded in the first sentence and the second sentence delivering a critical behavioral caveat. Every phrase adds informative value without waste.

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

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

The description adequately covers the core action and provider-specific behaviors, which is sufficient given the comprehensive schema and no output schema. Minor gaps exist, such as not describing the output format, but the overall context is clear for an agent to invoke 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?

Since the input schema has 100% description coverage, the baseline is 3. The description does not add parameter-specific meaning beyond the schema's own field descriptions; it only mentions provider differences that are already noted for individual 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's function: 'Create a silent looping idle video from one reference image.' This specific verb+resource combination distinguishes it from sibling animation tools by emphasizing the endless idle-loop nature.

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 generating idle-loop videos via the action verb and outcome, but it does not explicitly state when to use this tool over alternatives or provide exclusions. No sibling tools are mentioned, so usage guidance is only implicitly conveyed.

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 the annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false), the description discloses important runtime behaviors: headshots are used as identity references, the output is a stored image_url, default provider is Gemini, Grok caps at 3 actor references, and continuity_scene_frame_id preserves set/props/lighting but NOT pose/composition. No contradiction 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?

Six sentences, each earning its place: purpose, continuity workflow, actor filtering, composition reference, provider default, and timing use-case. It is front-loaded and reads naturally 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?

For an 11-parameter tool with no output schema, the description covers the essential operational context: what the tool returns (image_url), how to chain for continuity, how to preserve previs composition, and when to choose providers. The absence of an output schema is mitigated by mentioning the stored image_url return.

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, but the description adds high-value semantics: continuity_scene_frame_id resets pose/composition, composition_reference_url preserves previs camera/blocking, and actor_ids should be limited to visible actors. It clarifies that pose/composition parameters are reused per shot.

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

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

The description begins with a specific verb and resource: 'Generate one actor-grounded narrative first frame' from actor_ids plus location, wardrobe, pose, and composition. It also distinguishes itself from adjacent tools by stating 'Use this before animation when a close-up headshot is not enough,' clearly separating it from animation and character-video siblings.

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

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

Explicit workflow guidance is provided: 'For multi-shot continuity, first generate a wide scene reference, then pass its scene_frame_id...' and 'Pass only the actor_ids that should be visible in that shot.' It also explains when to use composition_reference_url and recommends provider switching via 'pass provider='grok''. The closing line gives a concrete alternative-use context against existing animation 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 mark readOnlyHint=true, so the read-only nature is known. The description adds value by specifying the authenticated-user requirement, the exact data returned (balance, usage, Stripe status), and that it is free to call. 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 a single sentence, front-loaded with the verb and resource, and contains no filler. Every word adds meaning, earning a high score.

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 there are no parameters and no output schema, the description is sufficiently complete for a simple read-only balance check. It clearly lists what the user gets. It could mention response format, but that is not essential for such a straightforward 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, and schema description coverage is 100%. With no parameters, the baseline is 4, and the description correctly focuses on the return value rather than explaining non-existent 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's function with a specific verb 'Return' and the exact resource: 'the authenticated user's current credit balance, usage, and Stripe subscription status.' It fully distinguishes from siblings, none of which relate to credits.

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 when to use it (checking credits) and adds 'Free to call' as a usage hint. However, it does not explicitly mention alternatives or exclusions. Since no sibling tools cover this functionality, the lack of explicit alternatives is acceptable.

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 read-only nature is covered. The description adds behavioral context by stating the operation is free and that it returns current values of editable fields, which provides useful information beyond the annotations without contradicting them.

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

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

The description is two sentences long and every word adds value. The first sentence states the function, and the second provides precise usage guidance without any redundancy or 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?

For a simple read-only listing tool with one parameter and no output schema, the description is complete: it explains what is returned (current values of editable text fields), when to use it, and how it relates to the generate tool. No further information is needed for an agent to select and invoke it correctly.

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

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

The input schema has full coverage (100%) for the single parameter template_id, with a description already stating 'The template ID to get text fields for.' The tool description does not add further semantic detail about the parameter, so the baseline of 3 applies since the schema handles the meaning 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 lists a template's editable text fields (headline, subhead, CTA, etc.) with current values. The verb 'list' and specific resource 'template text fields' make the purpose unambiguous, and it distinguishes itself from sibling tools like generate by explicitly positioning itself as a pre-generation step.

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 use it right after a template is chosen and BEFORE generate when precise field filling is desired instead of a freeform description. This provides clear when-to-use guidance and contrasts with the alternative, making the usage context unmistakable.

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 context beyond the readOnlyHint annotation: it discloses long-polling behavior ('keep this MCP call open'), the persistent URL on completion, and cross-thread authentication requirements. This is valuable operational information.

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 concise sentences, each adding distinct value: purpose, wait behavior and output, and authentication/thread context. No filler or redundancy.

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

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

For a simple status tool, the description covers purpose, wait mechanics, output details, and operational context. It is sufficiently complete given the lack of an output schema and the simple parameter set.

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 parameters are well-documented. The description enhances this by explaining that wait_seconds keeps the call open until completion/failure/cancellation, and that completed jobs include the S3 URL, which gives practical meaning beyond the raw 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 checks a queued MiniMax H3 video, with a specific verb ('Check') and resource ('MiniMax H3 video'). It distinguishes from sibling tools like queue_minimax_h3_videos and remove_minimax_h3_queue_job by focusing on status retrieval.

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 explains when to use the wait_seconds parameter and mentions the authentication requirement. While it doesn't explicitly say 'use this instead of X', the sibling tool names and the clear purpose make the usage context obvious.

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 the sparse annotations, the description discloses that the job is shared/visible in the website UI and MCP history, that build_bible/build_shot_plan can either run server agents or accept explicit inputs, that cancel_clip restores the exact pre-generation shot state, that generate_clip defaults to MiniMax H3 but can use the signed-in Grok sidecar, and that dialogue is plain text with provider tags applied later. This is substantial, though it does not cover auth, rate limits, 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?

The description is a single dense paragraph that front-loads the core purpose before detailing the workflow, provider defaults, and dialogue rules. At about 180 words it is long, but every sentence contributes necessary behavioral or workflow information for a genuinely complex stateful tool. It could be improved with bullet points, but the structure is appropriate for the 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?

For a 9-parameter orchestration tool with no output schema, the description covers the full stage sequence, agent override behavior, cancellation semantics, provider defaults, and dialogue constraints. It does not explicitly state what each action returns, but the schema's action descriptions fill the gap (e.g., planning_scaffold returns the compact continuity contract). Overall the description and schema together provide a reasonably complete picture.

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 descriptions already cover all 9 parameters (100% coverage), so the baseline is 3. The description adds practical workflow constraints: 'Pass plain dialogue lines of no more than eight words with speaker and voice_context; the renderer applies provider dialogue tags in the assembled prompt,' and it clarifies when to omit or supply production_bible and segments. This goes beyond the property-level schema documentation.

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

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

The description opens with 'Create and advance one shared twelve-clip, five-second composer job,' which clearly states the tool's action, resource, and unique scope. It distinguishes this from sibling tools like generate_character_video or extend_minimax_h3_video by focusing on the 12-clip/5-second shared job. The title and first sentence align, and the description immediately conveys the stateful orchestration nature of the tool.

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 an explicit sequential workflow: 'A client model should call planning_scaffold first, then author and submit... Use create with a story_brief, then build_bible... then build_shot_plan... then open_generation, and generate_clip.' It also explains cancel_clip's restoration behavior. It does not, however, explicitly name alternatives or state when not to use this tool, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden, and it delivers: it discloses that the tool is free, supports bounded offset pagination, returns newest first, and explicitly states what it never returns (internal identity prompts or visual descriptions). This is rich behavioral context beyond the schema.

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, dense sentence that packs purpose, scope, ordering, cost, pagination, and exclusions without wasted words. Every clause contributes meaningful 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 simple list tool with no output schema, the description covers the essential aspects: what it lists, whose, order, cost, pagination, and exclusions. It doesn't detail the response fields, but this is a minor gap given the tool's simplicity and the presence of pagination parameters.

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 defines limit and offset clearly. The description adds value by stating 'bounded offset pagination', which clarifies the pagination behavior and implies that offset has limits. This enriches the parameter semantics beyond the raw 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' and resource 'private reusable LetMeActForYou actors' with explicit scope 'authenticated user's' and sorting 'newest first'. This clearly distinguishes it from sibling tools like create_actor or my_auditions by focusing on private list 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 context is clear: this tool lists only the authenticated user's private reusable actors, implying it should be used when that specific scope is needed. It does not explicitly name alternative tools, but the 'only' and 'private reusable' wording provide implicit usage boundaries without exclusions.

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

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

No annotations are provided, so the description carries the burden. It discloses key behaviors (list only authenticated user's history, newest first, free, pagination, status filter) but does not mention potential rate limits, error conditions, or the exact response structure. It adds useful context beyond a minimal description, but not exhaustive.

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, front-loaded with the primary purpose, and every word earns its place. No filler or repetition.

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

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

For a list tool with three optional parameters and no output schema, the description covers purpose, scope, ordering, cost, pagination, and filtering. It lacks explicit return type details, but this is a minor gap given the simplicity of the tool.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters. The description adds concise confirmation of pagination ('bounded offset pagination') and the status filter's allowed values, but does not add substantially 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 ('audition history'), scopes it to 'the authenticated user's', and specifies ordering ('newest first'), clearly distinguishing it from sibling tools like audition_status 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?

While the description clearly indicates the tool is for listing the user's audition history, it does not explicitly mention alternatives or provide when-not-to-use guidance. Sibling tools such as audition_status and revise_audition are not referenced, leaving usage context implied rather than explicit.

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 the safety profile is covered. The description adds modest behavioral context by specifying ordering ('newest first') and job provenance. However, it does not disclose return format or pagination behavior, so it provides only limited value 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 a single sentence that is front-loaded with the action and resource, contains no redundant phrasing, and avoids unnecessary detail. Every word contributes to the core meaning.

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 read-only list tool with pagination parameters, the description covers the central purpose and ordering. It does not explain the return format or elaborate on what a 'minute clip job' is, but given the tool's simplicity and the presence of annotations, the description is nearly complete.

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

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

Schema description coverage is 0%, and the description does not mention the 'limit' or 'offset' parameters at all. The parameter names are self-explanatory, but the description fails to compensate for the missing schema descriptions, leaving the agent to infer pagination semantics.

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') with a precise resource ('shared parent composer jobs') and scope ('created from MCP or the DesignForYou video UI'), clearly distinguishing it from sibling tools like minute_clip_composer and other status/list tools. The ordering ('newest first') adds further specificity.

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 (to list shared parent composer jobs from specific sources), but it does not explicitly mention alternatives or exclusions. It lacks guidance on when to use other list/status tools such as my_actors or audition_status, so it falls short of a full 5.

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

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

Annotations only provide readOnlyHint false, destructiveHint false, and openWorldHint false. The description adds useful context about caller permissions and privacy of auditions, but it does not disclose important behavioral traits such as reversibility, what happens to the draft after publishing, or the output/return value. Since annotations are minimal, the description carries a larger burden and only partially meets it.

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

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

The description is concise (3 sentences) and front-loaded with the core purpose in the first sentence. Each subsequent sentence adds relevant context (permissions, privacy). No 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?

The purpose is clear, but the description lacks outcome details (e.g., what the response contains, whether publishing is reversible, how the public roster is affected). Since there is no output schema, the description should compensate by explaining the result of the operation, which it does not. It also omits explicit prerequisites beyond 'approved' video, though these are implied.

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 fully documents each parameter. The description's phrase 'approved seamless idle-loop video' mirrors the schema's 'approved seamless idle-loop MP4', adding no material semantic value. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the action: 'Promote an operator-owned actor draft into the shared public LetMeActForYou roster and bind its approved seamless idle-loop video.' This is specific, uses a strong verb ('promote'), identifies the resource (actor draft), and differentiates from sibling tools like create_actor or delete_actor.

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 this tool is appropriate: publishing a draft to the public roster. It also gives an explicit authorization constraint ('Only configured public actor publishers and first-party internal services can call this tool') and a privacy nuance ('Auditions remain private'). However, it does not explicitly name alternative tools or state 'use this instead of X', so it stops short of a 5.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false). The description compensates richly by disclosing credit cost (5 credits per prompt), queue persistence and auto-resume behavior, HQ output dimensions, and role semantics for images. This goes well beyond what annotations provide and adds 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?

Four information-dense sentences, each earning its place. It front-loads the core action, then systematically covers cost, duration, steps, quality, aspect ratio, images, and queue resilience without repetition. Highly 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 8 parameters and no output schema, the description covers key behaviors: cost, queue resume, image roles, and aspect/quality options. It omits return value details, but that is less critical for a queueing tool and sibling tools handle status/removal. Overall it is nearly complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable semantics beyond the schema: credit cost per prompt, hq=true output sizes, aspect-ratio pairing hints, and image role defaults (references by default). This enriches parameter 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 opens with 'Add one or more prompts to your private MiniMax H3 service queue', clearly specifying the action (add/queue) and resource (MiniMax H3 videos). It distinguishes itself from siblings like extend_minimax_h3_video, remove_minimax_h3_queue_job, and reorder_minimax_h3_queue by focusing on creation/queueing.

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 for queuing new video jobs, including when the service is unavailable ('Queued jobs resume automatically when the service returns online'). It does not explicitly mention alternatives or exclusions, but the context is clear enough given the sibling list.

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 the readOnlyHint annotation, the description discloses key behaviors: auto-detecting category, ranking by relevance, returning recommendations for user selection, and the exact condition to call generate. This adds meaningful context not present 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, front-loaded with the main verb and resource, and every clause serves a purpose: purpose, workflow, and explicit guardrail. No fluff 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 output schema and complete parameter descriptions, the description fully covers the tool's purpose, usage flow, and key constraints. It is sufficient for the agent to select and invoke correctly without additional context.

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

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

The input schema already covers all parameters with descriptions (100% coverage), including auto-detection for category. The description adds only a general 'Describe what you need' which overlaps with the use_case parameter. Minimal added semantic 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?

The description opens with a specific verb and resource: 'Recommend the best matching templates for any use case.' It clearly distinguishes from siblings like browse_templates (generic browsing) and generate (template generation) by focusing on auto-detection and relevance ranking.

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 when-to-use guidance ('any use case') and an explicit exclusion: 'do not call generate in the same turn unless the user explicitly names a template_id or asks you to skip selection.' This is concrete, actionable direction 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?

The annotations already declare destructiveHint=true, so the destructive nature is known. The description adds meaningful boundary context: it only applies to queued/failed/cancelled jobs, not active renders, and points to a safer alternative. This goes beyond the structured annotations without contradicting them.

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

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

Two concise sentences with zero redundancy. The verb and resource are front-loaded, and the alternative guidance is delivered in a single follow-up sentence. 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 simple one-parameter destructive tool with annotations present, the description provides sufficient context: purpose, valid job states, and the alternative for active renders. No output schema exists, so return-value explanation is not needed.

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

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

The schema covers 100% of the single parameter and describes it as a 'Queued MiniMax H3 job ID to remove.' The tool description broadens this by stating the job can be 'queued, failed, or cancelled,' which adds semantic nuance beyond the schema and helps prevent misuse.

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 the verb 'Remove' with a specific resource 'MiniMax H3 job' and narrows the scope to 'queued, failed, or cancelled' jobs. It also distinguishes from sibling tools by explicitly contrasting with the 'safe cancellation action' for active renders, making the 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 explicitly states when to use ('Remove one queued, failed, or cancelled MiniMax H3 job') and provides an exclusion with an alternative: 'For an active render, use the safe cancellation action instead.' This clearly guides selection against 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?

Annotations already indicate non-read-only and non-destructive behavior. The description adds valuable behavioral context, notably the guarantee that active renders are never interrupted, which goes 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?

Two concise sentences, front-loaded with the core action and a valuable safety note. Every word earns its place 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 tool with two parameters and no output schema, the description covers the essential behavior and safety constraints. It could mention edge cases like invalid request IDs, but the schema covers parameter semantics, so the description is sufficiently 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 description coverage is 100%, and both parameters are well-described in the schema. The description adds no additional meaning beyond what the schema provides, 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 uses a specific verb 'move' with a clear resource 'queued MiniMax H3 job' and scope 'one place earlier or later.' It clearly distinguishes itself from sibling tools like remove_minimax_h3_queue_job and queue_minimax_h3_videos.

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 clear context for use: moving a queued job and explicitly states it never interrupts an active render, implying it's safe to use during rendering. However, it does not explicitly mention when to use this tool over alternatives or 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 indicate this is a write operation (readOnlyHint=false) and not destructive. The description goes further by disclosing that it is free, stores only bounded triage metadata, and does not copy prompts, media URLs, billing data, or account identity. This is rich 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 two sentences, front-loaded with the primary purpose, followed by cost and privacy details. Every sentence adds value with no redundancy or 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 report submission tool with no output schema, the description covers the essential aspects: what can be reported, target ownership/visibility, cost, and data handling. It does not describe the response or confirmation behavior, but this is acceptable given the simplicity of the operation and 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 0%, so the description must compensate. It does clarify target_type semantics by specifying that actors must be visible and auditions must be owned by the user, which gives meaning to target_id and target_type. However, it does not explain the reason enum values or the details field, so parameter understanding is only partially addressed.

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 ('Report') and the specific resources: a visible actor or an audition owned by the authenticated user. It also introduces important scope constraints (visibility and ownership) that distinguish this tool from any sibling, and no other reporting tools exist.

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: to report a visible actor or an audition the user owns. It does not explicitly mention alternatives or exclusions, but since there are no sibling reporting tools, this is sufficient. The ownership/visibility condition effectively guides 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 discloses important behavioral details beyond the annotations: it inherits actor, story casting, cue, emotion, and line unless overrides are supplied, and preserves parent/root ids and the director note. This adds context about data flow and side effects. The annotations (readOnlyHint=false, destructiveHint=false) align with the create operation, and there is 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 compact and information-dense, consisting of two sentences that front-load the primary action ('Create a child take') and then efficiently list inheritance and preservation behavior. Every clause 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?

For a create-type tool with no output schema, the description sufficiently covers the essential behavior: what is created, what is inherited, and what is preserved. It does not explain the return value or potential side effects, but the annotations and schema fill in some gaps. Overall, it is complete enough for an agent to decide when and how to invoke the 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?

With schema description coverage only at 17%, the description partially compensates by explaining that optional parameters (cue, emotion, line) serve as overrides and that parent/root ids are preserved. However, it does not clarify the role of direction_notes (whether it is inherited or new) or fully explain the relationship between parent_audition_id and the created child take. The description adds some meaning but leaves gaps.

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: 'Create a child take from an existing audition.' This uses a specific verb and resource, and the phrase 'from an existing audition' distinguishes it from sibling tools like 'audition' (creating a new audition) and 'delete_audition'. The purpose is unambiguous and immediately actionable.

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: whenever a new take based on an existing audition is needed. It does not explicitly mention alternatives or when not to use it, but the context is strong enough for an agent to infer the appropriate situation. Lack of explicit exclusions prevents a 5.

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

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

Annotations are minimal (readOnly=false, destructive=false, openWorld=true), so the description carries the transparency burden. It discloses credit costs (base 3, +2 per hi-res cell), the background-removal behavior, the fixed-grid cropping, and the cell-resolution limitation that hi_res_cells addresses. This goes far beyond the structured 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 dense and front-loaded: the first sentence captures the full pipeline, and the optional hi-res details are placed after the base behavior. No filler or repeated schema information; every sentence adds material context like credits, resolution limits, or model override behavior.

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 is remarkably complete. It explains the main workflow, costs, optional hi-res enhancement, and model routing. Because an output schema exists, the absence of return-value details is acceptable.

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 only 25%, so the description must compensate. It does add significant meaning for quality.hi_res_cells and quality.hi_res_model by explaining costs, purpose, and model routing, but it leaves most other core parameters (character, style, sheet, cells, output, provider) to the schema. The schema's nested titles and defaults help, but the description only partially fills the gap.

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 ('Generate') plus resource ('visual-novel character sprite sheet') and enumerates the exact pipeline steps: crop, chroma-key removal, validation, and manifest output. It clearly distinguishes this tool from siblings like generate_character_video or generate_scene_frame by scoping it to VN 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 gives clear context for when to use the tool: to produce a VN Creator-ready sprite sheet with fixed-grid cropping and background removal. It does not explicitly name alternatives or exclusion criteria, but the specificity and billing details make the intended use 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?

The annotations already declare readOnlyHint=true and openWorldHint=false, but the description adds valuable behavioral context: 'no-cost,' 'does not generate images, use an LLM, or charge credits,' and 'fixed' payload. This goes beyond the annotations to clarify side-effect-free behavior and tool limitations, though it doesn't detail the return payload shape (but output schema exists).

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, front-loaded with the core purpose, and every clause earns its place. It is concise without being under-specified.

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 optional parameter, existing output schema, and clear annotations, the description fully covers the context: what it does, when to use it, what it avoids, and its cost behavior. No additional context is needed to use it correctly.

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

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

Schema coverage is 100% and the parameter 'mode' has a clear description ('Which widget payload shape to return without generation') and a pattern defining allowed values. The description adds little extra meaning beyond the schema, just emphasizing 'fixed' and the debugging context. Baseline 3 is appropriate since 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 tool's purpose: 'Return a fixed, no-cost DesignForYou widget payload for ChatGPT Apps debugging.' It specifies the verb (return), resource (widget payload), and purpose (debugging). It also distinguishes itself from siblings by explicitly noting it 'does not generate images, use an LLM, or charge credits.'

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

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

The description gives explicit when-to-use guidance: 'Use this only to verify the template gallery/result iframe renders correctly.' It also provides exclusions by stating what it does NOT do (generate images, use an LLM, charge credits), effectively telling the agent when not to use it and implying alternatives.

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