MascotLab

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

The description adds meaningful behavioral details beyond the annotations: it explains the server-side waiting behavior, the recommended wait_seconds value, the fact that it returns as soon as the render settles, and that completed results include a short-lived download URL. This enriches the agent's understanding of the tool's runtime 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 three sentences long, each carrying essential information. It opens with the core purpose, then explains the wait mechanism with a recommendation, and finally notes the download URL. No filler or redundancy.

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

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

Given that the tool has only two parameters and an output schema exists, the description sufficiently covers behavior, expected usage patterns, and outcomes. It explains the waiting strategy, response timing, and the presence of a download URL, making it complete for the tool's complexity.

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

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

The schema already documents both parameters with 100% coverage, so the baseline is 3. The description adds context: generation_id is sourced from create_* tools and wait_seconds controls server-side wait time, including a recommended value. This contextualization goes beyond the raw schema definitions.

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 the status of a generation_id from any create_* tool. This distinguishes it from sibling create tools (which generate) and download_artifact (which retrieves artifacts). The verb 'check' and resource 'generation_id' are specific and unambiguous.

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

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

The description implies the right usage context: after calling a create_* tool. It provides practical guidance on wait_seconds (recommended 45) and expected call counts for images vs. animations. It does not explicitly mention alternatives, but no direct alternative exists for status checking among the siblings, so 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 adds substantial behavioral context beyond the annotations: it costs 5 credits, requires an active subscription, produces a silent MP4, returns a generation_id, takes 1-3 minutes, and explains loop vs. end_pose_id semantics including morphing behavior. No contradictions with annotations are present.

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

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

Two sentences deliver all critical information: action, prerequisites, output, async timing, and polling guidance, with no filler. The structure is front-loaded with the core purpose, then flows into operational details.

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

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

Given the output schema exists, the description covers everything needed for an agent to select and invoke the tool: cost, subscription, output type, generation_id response, and explicit polling instructions. The combination of schema, annotations, and description fully equips the agent.

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

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

Schema coverage is 100% (all five parameters have descriptions), but the description enhances understanding by explaining that loop wins over end_pose_id, that end_pose_id can interpolate a different character (a morph), and that clip duration and output are silent. This adds interpretive value 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 ('Animates') and identifies the exact resources (a pose or mascot) and output (a short silent MP4 clip). It clearly distinguishes this from sibling tools like create_pose (still pose creation), create_mascot (mascot creation), and check_generation (status polling).

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

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

Explicitly instructs when to use the tool (to animate a pose/mascot) and gives concrete follow-up steps: call check_generation with wait_seconds 50 and repeat until it settles. It also clarifies the choice between loop and end_pose_id, guiding the agent on parameter 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?

Beyond the annotations (readOnlyHint=false, openWorldHint=true), the description adds crucial non-obvious behavior: credit cost and refund-on-failure, asynchronous generation with immediate ID, expected latency, and that the description is reused for all future poses/animations. This is valuable context the annotations do not provide and does not contradict 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?

Three sentences, each carrying essential information: purpose, cost/polling, and a critical architectural constraint. No filler or repetition of schema content. The most important operational facts are front-loaded.

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

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

The tool has an output schema and complete parameter documentation, so the description need not repeat those. It does cover the asynchronous workflow, cost semantics, latency, and the 'anchor' relationship to later poses/animations—making it complete for an AI agent to use correctly. The mention of check_generation also links to the sibling tool needed to complete the task.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds a meaningful hint that the description should be a single sentence with species/personality/look and that reference_mascot_id's description is reused. However, these are marginal additions beyond the schema, so the 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 begins with a specific verb and resource: 'Generates a new mascot character from a description'. This clearly differentiates from sibling tools like create_pose, create_animation, or create_prop, which target different artifact types.

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

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

The description gives clear workflow context: returns a generation_id to poll with check_generation and warns of the 10-40 second latency. It also explains that the mascot anchors later poses/animations, implying this should be created first. It does not explicitly state when not to use it or name alternatives, but the context is sufficient for correct 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?

Beyond annotations, the description discloses that this operation costs 2 credits (charged only on success), returns a generation_id for polling, and anchors identity to each mascot's reference sheet for on-model consistency. These are useful behavioral details not present in the annotations. It stops short of describing failure modes or rate limits, but the key side effects (cost, generation) are transparently communicated.

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 concise sentences: it opens with the main purpose, then adds cost/identity details, and ends with the return value. Every sentence provides necessary information with no redundancy or filler. It is well-structured and immediately communicates the tool's essential 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?

The description is complete for a generation tool with six parameters. It explains the core functionality, cost, identity tracking, and the expected output (generation_id). It references related tools (get_board, check_generation) to place it in the workflow. The rich schema and output schema cover parameter details and return format, so the description need not repeat them.

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 each parameter is already well-documented. The description adds some context by mentioning optional props and second mascot, but these are paraphrases of the schema. The statement about identity anchoring provides a little extra meaning for mascot_id, but overall the description does not significantly enhance parameter understanding beyond the schema.

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

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

The description clearly states that the tool 'Renders a mascot performing an action' with optional props and a second mascot. This distinguishes it from siblings like create_animation (animation), create_mascot (mascot creation), and create_prop (prop creation) by focusing on static pose generation. The verb 'renders' plus the specific context makes 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 provides clear context for use: generating a mascot pose, optionally with props or a second mascot. It also indicates integration with check_generation via the returned generation_id. However, it does not explicitly name alternatives or state when not to use this tool, such as for animation, which could be inferred from the sibling list but is not stated.

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

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

With all annotations false, the description carries the burden of disclosing side effects. It explicitly mentions that the new project becomes the active one, which is critical behavioral context beyond the annotations. It does not detail error conditions or permissions, but the core side effect is disclosed.

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 primary action and includes the key behavioral consequence. It is concise with zero 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?

For a simple one-parameter tool with an output schema, the description covers the essential behavior (active project switch) and is sufficient. It could be slightly more explicit about prerequisites or alternative selection, but not required.

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

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

The input schema already provides a full description for the single 'name' parameter, so the tool description adds marginal semantic value. Baseline 3 is appropriate given 100% schema coverage.

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

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

The description clearly states the tool creates a new project and makes it the active one, which is a specific verb+resource+side-effect combination. It distinguishes itself from sibling create_* tools by explaining that subsequent create calls will land in the new project.

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 implies usage context: this should be called before other create_* operations to establish the active project. It does not explicitly name alternatives like select_project, but the guidance is clear enough for an agent to infer when 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?

The description adds meaningful behavioral details beyond the annotations: it mentions the 2-credit cost charged only on success, the return of a generation_id for asynchronous checking via check_generation, and that props are reusable across poses. This complements the readOnlyHint and idempotentHint annotations without contradiction.

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

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

The description is two sentences: the first delivers the core purpose with examples, and the second covers cost, return value, and reusability. Every phrase earns its place, 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?

Given the tool's simplicity and the presence of an output schema, the description covers the essential context: purpose, cost, generation flow, and cross-pose reusability. It does not describe failure modes or lifecycle details, but these are not necessary for a straightforward creation tool with documented output.

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

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

With 100% schema coverage, the description does not need to explain parameters. It adds examples ('a red pipe wrench') to illustrate the 'description' parameter, but does not introduce new semantics beyond the schema's own descriptions.

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

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

The description clearly states the tool's function: 'Generates a standalone object the mascot can hold or use' with concrete examples ('a wrench or a coffee cup'). This distinguishes it from sibling tools like create_pose or create_animation by focusing on a reusable prop resource.

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

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

Usage is implied through 'Props are reusable across poses' and the return of a generation_id for check_generation, but the description does not explicitly state when to prefer this tool over alternatives or provide exclusions. It gives context but lacks direct guidance.

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

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

The description discloses the temporary nature of the URL (valid 10 minutes) and the need for prompt fetching, adding valuable behavioral context beyond the readOnly and idempotent annotations. It does not mention auth or rate limits, but the core behavior is adequately covered.

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

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

The description is concise, with two front-loaded sentences that state the purpose, supported artifact types, usage instructions, and a practical example. 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?

The description fully equips the agent with necessary information: what the tool does, how to invoke it, and what to do with the result. Since an output schema exists to document the return value, that aspect is already covered, leaving 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 covers both parameters with descriptions, achieving 100% coverage. The description adds extra meaning by mapping kind values to file types (PNG/MP4) and clarifies the source of IDs (get_board), thus supplementing the schema effectively.

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 identifies the tool as generating a fresh download URL for artifacts, specifying the supported types (mascot, prop, pose, animation) with file formats. This distinguishes it from sibling creation tools, as it is the only download-related operation.

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

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

The description provides explicit usage instructions: use IDs from get_board, fetch the URL promptly, and exemplifies with curl. It gives clear context for when to use this tool, and since no alternative download tool exists among siblings, exclusions are unnecessary.

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 the tool read-only and idempotent. The description adds value with specific cost details and the advisory to check balance before spending, which is helpful behavioral context beyond the annotation flags.

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: first identifies the data payload, second provides a usage directive. 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?

With no parameters and an output schema present, the description sufficiently covers the essential information: what data is available and when to call it. 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 tool has zero parameters, so there is nothing to document. The schema covers all properties (none), and the description doesn't need to add parameter 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 explicitly enumerates the tool's contents: credit balance, subscription state, and generation costs. It clearly distinguishes this from sibling creation tools by focusing on account/credit information.

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

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

It gives explicit usage context: 'Call this before expensive work to know what the balance allows.' This tells the agent when to use it, though it doesn't mention alternatives or exclusions.

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

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

Annotations already declare read-only/idempotent. The description adds useful behavior: it includes in-flight generations, returns IDs for other tools, and defaults to the active project when no project_id is given. This goes beyond annotation coverage.

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

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

Single sentence packs purpose, scope, and default behavior 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?

Given it's a simple read with one optional parameter and an output schema exists, the description is sufficient. It covers what data is included and default project 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?

The schema covers project_id with description. The description reinforces the default behavior and adds meaning about IDs being consumed by other tools, which helps understand the parameter's purpose.

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

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

Description clearly states the tool retrieves everything in a project (mascots, props, poses, animations, in-flight generations) and provides IDs used by other tools. This distinguishes it from sibling list_projects (which lists projects) and create_* 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 implies use when you need complete project contents, noting it defaults to the active project. However, it does not explicitly mention when not to use it or point to alternatives like list_projects for project metadata, so it's clear but not fully 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 this as read-only, idempotent, and non-destructive, so the bar is lower. The description adds meaningful behavioral context beyond annotations by revealing that the tool also reports which project is active, and that active project determines where generations land. This is useful for the agent's decision-making without contradicting any annotation.

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 exceptionally concise—two short sentences—with the main purpose front-loaded. Every phrase adds value, including the crucial detail about generations and the active project. There is no waste 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?

Given there are no parameters and an output schema exists, the description fully covers what the agent needs: it lists projects and identifies the active one, with contextual relevance for generation. The absence of return-format details is acceptable because the output schema presumably documents that. For a simple list tool, this is complete.

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

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

The tool has zero parameters, so the description carries no parameter burden. The baseline for 0-parameter tools is 4, and the description is sufficiently clear about what the tool returns, making it adequate. There is no schema information to elaborate on.

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 ('list') and resource ('the user's MascotLab projects'), and adds useful specifics: it returns ids and indicates which project is active. This distinguishes it from sibling tools like create_project or select_project by focusing on listing/reading rather than mutating or selecting.

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 see the user's projects and which one is active. The note that 'Generations always land on the active project' implies a common use case (checking the active project before generating). However, it does not explicitly mention alternatives or exclusions, so it falls short of a 5.

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

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

Annotations already cover idempotency and non-destructiveness. The description adds value by explaining the side effect on create_* tools, which is a behavioral trait beyond the annotations. It does not contradict annotations and provides useful context about the global active-project state.

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 function and followed by a consequential usage note. Every word earns its place; no fluff 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 simple state-setting tool with a single parameter, complete schema, and an output schema, the description covers purpose, usage, and impact on sibling tools. It is appropriately complete without needing to explain return values or errors, which are handled by structured fields.

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 fully describes project_id as 'A project id from list_projects,' achieving 100% coverage. The description adds no additional parameter semantics, but the schema already provides sufficient meaning. Per the rubric, this is a baseline 3.

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

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

The description clearly states the tool's function: 'Makes a project the active one.' It also specifies the broader impact by noting that create_* tools generate into the active project, which distinguishes it from sibling tools like list_projects and create_project. This is a specific verb+resource with clear scope.

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 usage context: 'switch first when working across projects.' It identifies the relationship with create_* tools, implying when to use select_project (before creating when using multiple projects). However, it does not explicitly state when NOT to use it (e.g., when staying within a single project), leaving a minor gap.

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