Sceneplane

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

The description goes well beyond the annotations by explaining the URL mechanics (credential in query string, no headers), verifiable response fields (byte count, SHA-256), precise 401/404/403 semantics, and the edge-protection User-Agent pitfall. This is exactly the kind of behavioral context that annotations cannot convey.

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

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

The description is front-loaded with the core purpose, followed by valuable operational details and a clear error-code warning. The anecdote about the 31-artifact download pass is slightly verbose but reinforces the User-Agent warning; overall every sentence 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?

With no output schema, the description compensates by naming the key response elements (byte count, SHA-256) and detailing error behavior. It does not state the URL expiration time or the full set of metadata fields, but the essentials for calling and using the result are present.

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

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

The input schema has 100% description coverage for the single parameter, artifactId, so the schema already defines the parameter. The description adds no additional parameter-level meaning, which matches the baseline of 3 for high schema coverage.

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

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

The description states a clear verb and resource: 'Get artifact metadata plus an expiring authorized download URL.' This is much more specific than the title, and the mention of metadata plus a download URL distinguishes it from siblings like artifacts_list. An agent can tell exactly what this tool returns.

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 intended use is implied by the purpose statement, and there is useful client guidance about User-Agent handling and error codes. However, it does not explicitly say when to choose this tool over sibling tools like artifacts_list, nor does it state when not to use it.

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

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

Annotations already mark it read-only, idempotent, and non-destructive. The description adds observable behavior: newest-first ordering, every entry carrying the producing revision, and recovery of lost artifact ids without walking jobs_list.

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 distinct information: what the tool lists, why revision info matters, and where download URLs live. No filler or restatement of the title.

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 read-only list tool with an output schema, the description supplies key selection criteria, ordering, filter options, and the sibling relationship. Pagination is left to the schema's cursor field, which is acceptable given the output schema exists.

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

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

Schema coverage is 100%, so the schema already documents projectId, kind, limit, cursor, and revisionId. The description adds only high-level filter and ordering context, which is useful but not needed to compensate for missing parameter docs.

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

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

States a specific action ('List a project's artifacts'), scopes it to a project, and specifies ordering ('newest-first') and supported artifact kinds. It also distinguishes itself from artifact_get by noting that download URLs live there.

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?

Names artifact_get as the source for download URLs and jobs_list as a heavier alternative for recovering artifact ids, giving an agent clear routing cues. This is explicit enough to choose this tool over siblings without opening their schemas.

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 readonly/destructive/idempotent safety. The description adds useful behavioral context beyond annotations: it is an asynchronous generation workflow requiring polling, provider-specific input constraints, and a required integrations_set token. It stops short of discussing limits, failures, or latency, but the additions are meaningful.

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 packs a high density of useful information into three focused sentences. The primary purpose is front-loaded, and provider constraints and follow-up steps are introduced in a logical order without 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?

Given the rich schema coverage, output schema, and annotations, the description provides everything an agent needs to invoke the tool correctly: the object scope, the provider differences, the auth prerequisite, and the downstream polling/import steps. The explicit source and slug format for the follow-up import closes the loop.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description goes beyond the schema by clarifying which providers accept imageUrl versus prompt-only, and by tying the provider choice to the required integrations_set token and the eventual import source.

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 specific action ('Start a text/image → 3D generation') with a clear scope ('ONE freestanding object per task'). It differentiates itself from scene operations and from the later status/import steps, so an agent can distinguish it from sibling tools like asset_generate_status and asset_library_import.

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 workflow guidance: generate, then poll asset_generate_status, then import with asset_library_import using source and slug. It also tells the agent not to build ground planes or assemblies with this tool and instead use scene operations, and names the required integration token setup via integrations_set.

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

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

Annotations already declare readOnly and idempotent behavior, so the description's extra context about needing the same provider and subscriptionKey and the next import step adds useful behavioral boundary. It accurately reflects a non-destructive polling operation and has no contradiction with the annotations.

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

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

Two short sentences deliver the polling purpose, the required identity context, and the success-path next step with zero filler. The content is front-loaded and every clause earns its place.

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

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

For a two-parameter, read-only polling tool with a full output schema, the description is complete: it explains what to pass, what to wait for, and what to do after. The agent has all the context needed to call the tool correctly and continue the 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?

Schema coverage is 100%, so the description does not need to re-document the parameters. It reinforces that provider and subscriptionKey should match the originating generation request, but this mostly restates the schema's existing 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 opens with a specific action, 'Poll a generation', and ties it directly to the output of asset_generate_3d, so an agent knows exactly what this tool is for. It also distinguishes the tool from the generation and import siblings by framing it as the middle polling step of the workflow.

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 states the precondition (generation started by asset_generate_3d with the same provider and subscriptionKey) and gives a clear transition condition to asset_library_import when status=done. It does not explicitly list alternatives or when not to use the tool, but the workflow condition is specific enough to select it correctly.

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, non-idempotent, and open-world. The description adds meaningful behavioral context by disclosing that the call returns a durable job handle, implying asynchronous processing and poll-ability. It does not contradict 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?

Two sentences with no filler: the action and destination are front-loaded, and the durable job handle result is stated directly. 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?

The description is too thin for an 8-parameter mutation tool with low schema coverage. It leaves the caller to infer the meaning and provenance of several key parameters, and while the output schema may document the return value, the description does not provide enough operational context for correct invocation.

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

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

Schema description coverage is only 38%, leaving assetId, format, placement, unitPolicy, and targetCollection without explanatory context. The description does not compensate for this gap and adds no parameter-level meaning beyond what the schema already has.

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 gives a specific action ('Import'), a specific resource ('a validated uploaded asset'), a destination ('into a project as a new revision'), and a result ('Returns a durable job handle'). The phrase 'validated uploaded asset' distinguishes this from the sibling asset_library_import without needing to open the schema.

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

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

The description states a clear usage context: the asset must already be validated and uploaded, and the tool creates a new revision in a project. It does not explicitly mention exclusions or alternatives, such as 'use asset_library_import for library assets', so it stops short of an explicit when/not guidance.

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

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

The description discloses key behaviors beyond annotations: it returns a job handle (async), explains source-specific transformations (HDRI becomes world environment, texture sets become wired PBR material), and mentions scaling. It also notes the token requirement for Sketchfab. These are valuable details not captured by annotations. It does not contradict the annotations (readOnlyHint false, openWorldHint true, etc.).

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 but well-structured, starting with the core purpose and then using clear 'source=' segments to organize source-specific details. Each clause carries necessary information, and the front-loaded main sentence gives immediate context. It is appropriately sized 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?

Given the tool's complexity (10 parameters, multiple sources, async job handle) and the presence of an output schema, the description covers the essential behaviors: revision creation, job handle, per-source semantics, token requirement, and scaling guidance. It also ties into asset_generate_3d for generation tasks. The description is thorough and leaves little ambiguous for an agent to call 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?

With schema description coverage only at 30%, the description adds substantial meaning for parameters like slug (explaining what it means per source), source (enum meaning), targetSize (with real-world examples), and applyToObjects (assignment behavior). This significantly compensates for the low schema coverage and helps agents understand parameter usage without opening the schema.

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

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

The description clearly states the verb 'import', the resource 'library asset', and the outcome 'into a project as a new revision', plus it returns a job handle. It is specific enough to distinguish from the sibling 'asset_import' by focusing on library sources and revision semantics, even without naming the sibling explicitly.

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

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

The description provides clear context on how to use the tool across different sources (polyhaven, sketchfab, hyper3d/hunyuan3d/tripo3d), including source-specific requirements like the Sketchfab token and taskUuid from asset_generate_3d. It also explains scaling with targetSize. However, it does not explicitly state when not to use this tool versus the sibling 'asset_import', so it lacks a direct exclusion.

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 communicate that the tool is read-only, idempotent, and non-destructive, so the description does not need to repeat those facts. It adds useful context about slug provenance and provider types, though it does not describe error behavior or output details beyond the inline image.

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

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

Two short sentences deliver the core purpose immediately and then pin down the slug/source semantics. There is 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 simple read-only preview tool with rich annotations, the description covers what it does, its output form, and its input provenance. Nothing essential is missing for an agent to decide when and how to call it.

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 provides full descriptions for both parameters, including source enum values and defaults. The description reinforces that slug comes from assets_search, but adds no major semantic 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 states a specific verb ('see'), a concrete resource ('asset's thumbnail as an inline image'), and the associated workflow phase ('before importing it'). This clearly distinguishes asset_preview from import tools without requiring schema inspection.

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 frames the tool as a pre-import preview step, giving clear context for when it is appropriate. It does not explicitly list alternative tools, but the 'before importing' wording makes the intended usage evident.

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 establish read-only, idempotent, non-destructive behavior, lowering the burden on the description. The description adds useful behavioral context by mentioning per-category counts and that categories can be passed as search queries, going beyond what the annotation block alone provides.

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 filler: the first states the core action and output characteristic, and the second provides usage guidance for the related sibling tool. 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?

With one required enum parameter, full schema coverage, an output schema, and safety annotations, nothing needed to call the tool correctly is missing. The description also covers the likely next step by connecting categories to assets_search.

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 single 'type' parameter is fully documented in the schema with an enum and a clear description, so the description doesn't need to add much. The phrase 'for an asset type' maps to that parameter but adds no format or value detail beyond the schema.

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

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

The description states a specific action ('List'), a concrete resource ('Poly Haven categories'), and a scope ('for an asset type'), plus a distinguishing detail ('per-category counts'). It also references assets_search, making clear this tool is for browsing the category taxonomy rather than searching assets.

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 a clear follow-up directive: 'Pass a category as the assets_search query to filter,' which tells the agent when to hand off to assets_search. It does not explicitly enumerate exclusion conditions like 'use only when you need categories,' so the guidance is strong 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?

Beyond the annotations, it discloses the return contract (slugs for a downstream tool), default source, CC0 licensing for Poly Haven, and the Sketchfab integration prerequisite. It doesn't mention rate limits or side-effect behavior, and the readOnlyHint=false annotation makes the safety profile slightly ambiguous for a search tool, but there is no direct 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 information-dense with the core purpose front-loaded in the first clause. Each sentence adds real value, though the long parentheticals make it slightly harder to parse; a bulleted source breakdown would improve scannability without adding length.

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 full parameter schema, output schema, and annotations, the description provides the missing operational context: what the returned slugs are for, which source needs setup, which source is restricted, and licensing requirements. Nothing essential is missing for an agent to decide to call this tool.

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

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

The schema already documents all four parameters with 100% coverage, so the baseline is 3. The description adds meaning beyond the schema by explaining source-specific behavior: default source, no setup, type=model restriction, integration requirement, and license obligation. It does not add new detail for limit/query, but the schema covers them.

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 and resource: 'Search free 3D asset sources by keyword' and clearly states the output ('returns slugs for asset_library_import'). It also distinguishes the two supported catalogs (Poly Haven vs Sketchfab), so an agent can separate it from asset_import, asset_generate_3d, and assets_categories.

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 selection guidance inside the tool: Poly Haven is the default and needs no setup, while Sketchfab requires integrations_set and is limited to type=model with license obligations. It doesn't explicitly name sibling alternatives or state when not to use the tool, but the setup and source-specific conditions are strong practical 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?

Discloses key non-obvious behavior: output is deterministic given the same payload and seed, and the result is delivered as an audio_wav artifact with a download URL in job_get. Since no output schema exists, this is valuable; annotations only provide generic hints and nothing contradicts the description.

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 dense sentences front-load the purpose and parameter categories, with no filler. The lists are compact, and each sentence adds a distinct fact: what is generated, determinism, and how the artifact is delivered.

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, no-output-schema job tool, it covers the typical workflow: artifact and download URL in job_get, parameter scoping by audio kind, and deterministic guarantees. It could say more about the async job lifecycle, but the job_get reference is likely sufficient.

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

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

With only 45% schema description coverage, the description compensates by grouping the BGM parameters (bpm, bars, root, scaleMode, voice) and linking presets to sfx/jingles and seed to determinism. It doesn't exhaustively define every enum value, but it clarifies the main parameter relationships.

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

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

States a specific action (synthesize deterministic 16-bit PCM WAV), names the output artifact, and enumerates the three audio kinds: sfx presets, win/lose jingles, and loopable BGM. This clearly distinguishes it from asset_generate_3d and other resource-generating siblings.

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

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

The description gives concrete use cases and parameter groupings: sfx presets, jingles, or BGM loops, and notes exact-bar looping. It stops short of explicitly naming when-not-to-use alternatives, but the context is clear enough for an agent to select it for game-audio generation.

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, idempotentHint, and destructiveHint, and the description adds substantial context: ownership/checksum constraints, the exact measurement set, preview audio return behavior, and explicit limitations. 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?

Two sentences with no filler: the first front-loads the core action, resource, and measurement list; the second compactly covers preview behavior and non-goals. 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?

Covers purpose, measurements, preview behavior, and non-goals despite having no output schema. The main gaps are the undocumented previewOffsetSeconds parameter and lack of return-structure detail, but for a read-only inspection tool with strong annotations this 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 only 33%, so the description must compensate. It clarifies previewSeconds ('returns up to three seconds as playable MCP audio') but leaves previewOffsetSeconds entirely unexplained in both the schema and the description, leaving a meaningful parameter without semantic guidance.

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

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

States a specific verb ('Measure') and resource ('checksum-verified owned PCM16 WAV'), then enumerates concrete metrics such as peak/RMS/DC, clipped samples, and loop-boundary differences. It also explicitly contrasts with non-goals ('does not listen, judge sound quality, measure LUFS or certify a seamless loop'), making it clearly distinguishable from siblings like audio_generate and artifact_get.

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: this tool is for measuring sample-level properties without Blender compute, and it explicitly lists exclusions such as not judging sound quality or measuring LUFS. However, it does not name a specific sibling tool to use instead, so the guidance is strong 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 readOnlyHint=false, destructiveHint=false, idempotentHint=false, so the description doesn't need to restate those. It adds useful behavioral context: the permission requirement (owner/admin) and the organization defaulting behavior. It doesn't mention what the response contains, but an output schema exists, so that burden is reduced.

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?

One sentence, front-loaded with the action and resource, then the two most important usage constraints. No wasted words.

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

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

For a create tool with an output schema and full parameter documentation, the description covers the key non-obvious context: permission requirements and organization defaulting. It doesn't explain what 'isolated' means or what happens on failure, but those are minor given the output schema and annotations.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds the organization defaulting behavior, which clarifies when organizationId can be omitted, but it doesn't add much beyond that. 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 states a specific verb ('Create') and resource ('new isolated Blender deployment'), and the title reinforces it. It distinguishes from siblings like deployment_update and deployment_delete by focusing on creation, and the 'isolated' qualifier adds 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 gives clear context: requires owner/admin in the target organization, and defaults to your only organization when you have exactly one. It doesn't explicitly name alternatives or when-not-to-use, but the permission and default behavior guidance is strong enough to guide correct invocation.

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 signal destructive intent, but the description adds materially more: permission requirements, the empty-deployment precondition, and the refusal behavior when projects still exist. This tells the agent what to expect beyond the binary destructive flag.

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 filler. The most important constraint (EMPTY) is front-loaded, and the precondition/refusal behavior is compressed into the second sentence.

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

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

Given only one parameter, full schema coverage, an output schema, and annotations that cover destructive behavior, the description covers all necessary operational context: permission, precondition, and failure mode. Nothing essential is missing for an agent to invoke this correctly.

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

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

Schema coverage is 100%, with the single deployment parameter fully described as 'deployment slug' in the schema. The description adds no extra parameter details, but for a single self-explanatory parameter, 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?

States a specific action ('Delete') on a specific resource ('deployment') with a critical qualifier ('EMPTY'), making its purpose unmistakable. It distinguishes itself from related deployment operations like deployment_create and deployment_update.

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 preconditions: only owner/admin, only empty deployments, and that projects must be deleted first. It doesn't explicitly name an alternative tool, but the guidance clearly tells when not to invoke this tool directly and what to do instead.

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 destructiveHint=true and readOnlyHint=false, so the description goes beyond them by adding concrete behavioral context: dangerousScriptingEnabled unlocks scene_script, permission levels are specified, values are validated against platform bounds, and every change is versioned. This meaningfully helps the agent anticipate side effects and reversibility.

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 dense sentences front-load the tool's action and scope, then efficiently pack permissions, validation, and versioning behavior. There is no filler or redundant restatement of the schema.

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

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

For an 11-parameter destructive mutation tool, the description provides key permission and versioning context, but it omits explicit differentiation from deployment_update and leaves several parameter semantics ambiguous. It is adequate for basic invocation but not fully complete for correct agent decision-making.

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 18%, leaving most parameters undocumented. The description maps broad categories like job timeouts, queue depth, and render caps onto the schema, and explicitly explains dangerousScriptingEnabled, but it leaves parameters such as maxOperationsPerMutation, approvalRequiredForRestore, and maxConcurrentJobs unexplained. This does not sufficiently 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?

The description opens with a specific verb ('Tune') and clearly targets 'a deployment's execution policy', then enumerates the concrete policy dimensions. It differentiates itself from the generic deployment_update via this execution-policy scope, though it does not explicitly name or contrast the sibling.

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 useful authorization context ('OWNER only', 'owner/admin') and implies the tool is for tuning execution policy, but it never explicitly states when to use this over deployment_update or when not to use it. Usage guidance is mostly implicit 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context: the result is scoped to the account's accessible deployments, and the active deployment for other tool families can be switched via the ?deployment=<slug> query parameter.

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 zero waste: the core operation and scope appear first, followed by the session/query guidance. Every sentence earns its place without repeating schema or annotation 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?

For a zero-parameter, read-only list operation with an output schema and full safety annotations, the description provides the essential extra context: account scope and the deployment-switching mechanism. Nothing needed to invoke the tool correctly is missing.

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

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

The input schema has zero parameters, so the baseline is high. The description goes further by documenting an actionable URL-level switch, ?deployment=<slug>, which is not represented in the schema and is important for controlling which deployment subsequent tools act 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 opens with a concrete verb and object, 'List every deployment this account can access,' adding account-level scoping to the title. This makes it clearly distinct from deployment_create, deployment_update, and deployment_delete without needing to name them.

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 frames the tool as the way to enumerate all accessible deployments and connects this to the session-bound deployment concept, implying this list is used to discover the slug for other tools. It does not explicitly name alternatives, but the context is clear enough for an agent 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the mutating nature is known. The description adds the permission requirement and the specific actions (rename, disable), which is useful context. However, it does not disclose side effects on existing work or how renaming affects references, though the annotation covers the core destructive trait.

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, tightly written sentence that front-loads the primary actions and the permission gate. It contains no filler or redundant phrasing, earning top marks for conciseness and structure.

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 update tool with an output schema present, the description adequately covers the core operation and the critical permission restriction. It does not mention preconditions like the deployment existing, but that is implicitly required and not a significant gap for this 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 input schema already documents all three parameters with descriptions (100% coverage), including the semantic meaning of 'name' and 'disabled'. The description does not add any additional parameter-level detail beyond what the schema provides, so it meets the baseline of 3.

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

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

The description specifies the exact operations (rename or enable/disable) on the deployment resource, and clearly states the owner/admin permission requirement. This distinguishes it from sibling tools like deployment_create and deployment_delete without needing to inspect schemas.

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 clear authorization constraint (owner/admin only) but does not explicitly mention when to use this tool versus alternatives like deployment_policy_update or deployment_create. The intended use is implied by the actions, but no explicit 'use this when' guidance or exclusions are given.

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 idempotentHint=true, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: it mentions did-you-mean suggestions for unknown names, the extra node socket details, and the fact that it reads from a 'pinned Blender build' because the official API reference omits socket lists. This goes beyond the structured metadata 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 dense but not bloated. Each sentence contributes: purpose, accepted input formats, unknown-name behavior, node-type special behavior, and the reasoning behind the node detail. The purpose is front-loaded in the first clause. Slightly long, but every part 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?

The tool has moderate complexity (special node-type handling) but the description fully covers input scenarios and the extra node info. An output schema exists, so return format is presumably documented there. The description doesn't mention authentication or rate limits, but those are not implied as needed. An agent knows exactly when to call and what to expect.

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% (the single 'identifier' param is described simply as 'Exact Blender Python API identifier'). The description massively expands on this by specifying accepted formats (dotted identifiers, wildcards like 'X.*', '*' for top-level, node type names) and what each returns. This is exactly the value the description should add 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 states a specific verb and resource: 'Verify bpy signatures, properties, and enum values' — clearly distinguishing it from sibling tools like docs_bpy_search (which likely searches) and docs_manual_get (which fetches manual pages). It also gives concrete input examples ('bpy.types.Object', 'bmesh.types.BMEdge.is_manifold'), 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 says to use it 'BEFORE writing scene_script code', providing a clear workflow context. It also explains the special node-type query path that returns socket names and hidden sockets, which isn't obvious. However, it doesn't explicitly contrast with docs_bpy_search or state when to use that alternative, so it's clear but not fully explicit about when not to use it.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior, so the description adds value beyond structured data by disclosing the UI-label alias behavior ('color ramp' finds ShaderNodeValToRGB) and ranking of results. It doesn't introduce any hidden side effects or contradictions.

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

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

Two efficient sentences with no filler. The core purpose and scope are front-loaded, examples are embedded compactly, and the special UI-label behavior is appended as a valuable clarification.

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 search tool with a fully documented 2-parameter schema and an output schema, the description covers purpose, query semantics, special matching behavior, and how results relate to a sibling tool. Nothing critical is missing for correct selection and invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description enriches the query parameter's meaning by showing that matching is not only over identifiers but also over node UI labels. It also implies the query string expects human-readable terms like 'subsurf modifier' rather than raw identifiers.

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 specific verb and resource: 'Keyword search over every documented bpy identifier'. It distinguishes itself from the sibling docs_bpy_lookup by explicitly positioning itself as the search step that feeds lookup, and from docs_manual_search by limiting scope to bpy API identifiers.

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 clearly indicates this tool should be used to find bpy identifiers, and that results are meant for docs_bpy_lookup. It provides concrete query examples and notes UI-label matching behavior, but it does not explicitly state when not to use it versus the manual search 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 this tool safe (readOnlyHint=true, idempotentHint=true, destructiveHint=false). The description adds useful behavioral context beyond annotations by stating it retrieves the page 'in full' and by identifying the source and license (blender.org, CC-BY-SA 4.0), which is relevant for reuse.

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 concise sentence contains the verb, resource, scope, and path source, followed by licensing information. No filler or redundancy; every phrase 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 one-parameter, read-only tool with a rich output schema and complete annotations, the description fully covers what an agent needs: what it fetches, how to identify the resource, and the license terms. Nothing essential is missing.

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

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

Schema description coverage is 100%, with the path parameter already documented as 'Manual page path returned by docs_manual_search.' The description reinforces this but adds no new semantic detail beyond what the schema provides. 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 states a specific verb ('Fetch'), a precise resource ('one Blender manual page in full'), and the required mechanism ('by its path'). It also references docs_manual_search, which distinguishes it from sibling docs tools like docs_bpy_search and docs_operations.

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

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

The description clearly implies the intended workflow: first use docs_manual_search to obtain a path, then call this tool with that path. It provides clear context but does not explicitly name alternatives or state when not to use it. No exclusions are given.

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 establish read-only, idempotent, non-destructive behavior. The description adds relevant behavioral context beyond that: full-text search, ranked results, snippets, and the recommended next step. There is 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 sentences with the core action and scope front-loaded, followed by concrete output expectations and a routing instruction. Every sentence earns its place and there is no redundancy or padding.

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 low-complexity search tool, the description, full schema, and rich annotations cover the main invocation need: what to query, what to expect in return, and how to proceed. It is minimally incomplete only in not explicitly warning that Blender API/symbol lookups belong with docs_bpy_search.

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 both query and limit. The description adds no additional parameter-level meaning such as query syntax, ranking behavior, or limit tradeoffs; 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 names a specific verb and resource ('Search the Blender user manual full-text') and narrows the purpose to conceptual questions about modifiers, shading, physics, animation, and constraints. This clearly distinguishes it from API-reference siblings like docs_bpy_search and from the read tool docs_manual_get.

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 clear context for when to use the tool: for conceptual manual questions, and it explicitly instructs the agent to follow up with docs_manual_get to read a result. It does not explicitly name docs_bpy_search as the alternative for API/symbol lookup, so it falls just 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 declare readOnlyHint, idempotentHint, and non-destructive behavior, but the description goes further: it says the tool 'queues no job, spends no compute and changes nothing' and is 'always safe to retry, including after a transport-level error'. It also explains that schemas are introspected from the validator itself, so results exactly match what scene_apply accepts. This is rich behavioral context beyond the annotations 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?

The description is long but every sentence earns its place: the primary use is front-loaded, alternatives and exclusions are stated early, and each optional parameter's behavior is covered efficiently. The 'READ ONLY and free' safety note is a deliberate closing signal. No filler or redundant restatement of schema fields.

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 six optional parameters, an output schema, and several sibling tools, but the description covers all necessary invocation patterns, special values, result formats, and the caveat about repeated-detail namespaces. It also explains the tool's cost/safety profile, which matters for an agent deciding whether to retry. An agent has everything needed to select and call this 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, but the description adds meaning the schema lacks: it explains op='guide' compatibility with older catalogs, what namespace='mesh' does, the caveat that repeated details live under object.radial_array rather than a 'pattern' namespace, and that search returns ranked matches. It also clarifies the format parameter's relationship to structuredContent, which adds real value for an agent choosing how to consume results.

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

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

States a specific verb and resource: 'Enumerate and inspect the validated operations scene_apply accepts'. It also distinguishes the tool from siblings by saying 'call this BEFORE reaching for scene_script' and noting most modeling does not need raw bpy, which separates it from the docs_bpy tools. No ambiguity about what the tool is for.

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

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

Explicitly names when to use the tool (before scene_script), when not to use raw bpy, and which sibling handles adjacent concerns ('validation is the separate scene_validate tool'). It also gives concrete conditional usage: guide=true for the guide, namespace for a namespace, search for ranked matches, op for a schema. This leaves little to inference.

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

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

The description goes well beyond the four boolean annotations: it discloses that selection is resolved against the exported revision, the response lists selected objects by type, stale ids fail loudly, curves without surfaces are skipped, a durable job handle is returned, and the file becomes an immutable artifact. These are exactly the behavioral traits an agent needs to predict side effects.

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

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

The description is dense but every clause earns its place: purpose is front-loaded, then engine conventions, selection failure behavior, curve handling, and the durable artifact output. For an 18-parameter tool, the length is justified and there is no filler or repetition of schema content.

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, the existing output schema, and the presence of defaults in the input schema, the description covers the essential operational context: formats, engine presets, selection semantics, failure modes, and async job behavior. Nothing critical for invoking it correctly appears to be missing.

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

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

With only 61% schema description coverage, the description meaningfully compensates by explaining enginePreset behavior in detail (overrides yUp/scaleFactor; print's Z-up/mm convention; unreal scaling), bake trade-offs, and selection/curve edge cases. It does not directly address every remaining parameter, but the decision-critical parameters are substantially enriched.

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 opening sentence names a specific verb and resource: 'Export a revision to GLB, OBJ, STL, or .blend.' The export formats and verb clearly separate this tool from siblings like render_create and asset_generate_3d, so an agent can identify it without opening the schema.

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

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

The description gives clear context for when to use it — when a revision needs to be exported to specific file formats — and then gives concrete decision guidance for engine presets and bake modes. It does not explicitly contrast against sibling tools such as render_create, but the context is strong enough to route correctly.

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 and idempotent behavior. The description adds meaningful behavioral context: it returns a prompt and upload/material steps, delegates image generation to the harness, and does not consume Blender compute. 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?

The description is three tight sentences with no filler. It front-loads the core purpose in the first sentence, then efficiently adds the return behavior and the key non-behavior (no image generation, no Blender compute).

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 high-level purpose and safety-relevant behavior, but it is thin for a tool with 19 parameters, nested objects, and no output schema. The return value is only vaguely described as 'a prompt and upload/material steps,' with no detail on output structure or how to translate inputs into those steps.

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 19 parameters and only 32% schema description coverage, the description needed to compensate by explaining how to choose or fill key fields like purpose, workflow, layout, or requestedMapRoles. It does not mention any parameter semantics beyond listing use categories, so most of the parameter burden remains on an under-covered 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 ('Plan') and resource ('source image'), enumerates concrete use cases, and explicitly differentiates itself from generation by stating the harness calls its own image tool. This clearly distinguishes it from sibling tools like asset_generate_3d or render_create.

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 a clear context and scope: planning source images for surfaces, decals, trim sheets, animation, etc. It also states what the tool does not do, implying when it isn't appropriate. However, it never explicitly names alternative tools or says 'use X instead,' so the routing guidance is implicit 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 indicate destructiveHint=true and readOnlyHint=false. The description adds valuable context by specifying that the operation deletes a stored token and requires owner/admin permissions, which goes beyond the annotations. No contradictions exist.

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

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

The description is two short sentences with zero redundancy. The core action is front-loaded ('Delete a stored third-party source token'), and the permission note is placed immediately after. 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 delete operation with one parameter and a destructive hint already set, the description covers the essential information: what is deleted and who can do it. The existence of an output schema reduces the need to describe return values, making this fairly complete. A minor omission is not explicitly stating that deletion is irreversible, but that is implied by destructiveHint.

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

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

There is only one parameter (provider) and its description in the schema ('Configured integration to remove.') is clear and covers 100% of the schema. The tool description does not add any additional meaning about the parameter, so the baseline of 3 is appropriate since the schema handles it well.

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) and resource (stored third-party source token), which distinguishes it from integrations_set and integrations_list. The title 'Remove a source integration' reinforces the action.

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

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

The description mentions the access prerequisite (owner/admin) but does not provide any guidance on when to use this tool versus alternatives like integrations_set or integrations_list. No explicit exclusions or comparisons to sibling tools are given.

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 read-only, idempotent, and non-destructive behavior. The description adds context beyond those annotations by disclosing that the tool returns masked hints only, never tokens, and that it lists only configured integrations. This is valuable behavioral information that prevents incorrect assumptions about the output.

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 with zero filler. It front-loads the core action and resource, then immediately provides the security-relevant output constraint ('masked hints only, never tokens'). 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?

Given the presence of an output schema, zero parameters, and annotations that fully cover the safety profile (read-only, idempotent, non-destructive), the description is complete. The masking note clarifies a crucial aspect of the return value, so nothing an agent needs to invoke this tool correctly is missing.

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

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

The tool has zero parameters, and the input schema is an empty object with coverage effectively at 100%. The baseline for zero-parameter tools is 4, and there are no parameter details to explain. The description's mention of output masking covers what the tool returns, not parameters, which 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 ('List') and resource ('configured third-party source integrations'), making it immediately clear what this tool does. It also adds a crucial qualifier ('masked hints only, never tokens') that differentiates it from other integration operations and sets expectations about output. This fully distinguishes it from siblings like integrations_set and integrations_delete.

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

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

The description explicitly states the purpose, which signals when to use the tool: when an agent needs to view configured source integrations. It does not name alternatives, but no sibling tool provides the same listing function (integrations_set and integrations_delete are mutators, not alternatives). Clear context with no exclusions earns a 4.

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

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

Annotations already indicate destructiveHint=true, and the description adds valuable context beyond annotations: tokens are encrypted at rest, owner/admin permission is required, and provider-specific integrations are enabled. It does not explicitly say that setting a token overwrites an existing one, but the destructive hint covers that risk.

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

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

The description is front-loaded with the core action and security context, then organized by provider with consistent formatting. Every sentence adds useful information—there is no filler or redundant restatement of the tool name or schema.

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

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

For a two-parameter tool with full schema coverage and an output schema, the description is complete: it covers permission requirements, encryption, provider-specific token sources, and downstream effects. An agent has everything needed to call the tool correctly without additional documentation.

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?

While schema coverage is 100%, the description adds significant meaning by mapping each provider enum value to its token source and the feature it enables. This goes well beyond the schema's generic 'Provider-issued API token' and helps the agent construct correct values.

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 specific action ('Store a third-party source API token') with the resource scope ('for the organization') and encryption detail. It clearly differentiates from sibling tools like integrations_delete and integrations_list by focusing on configuration/setup rather than removal or listing.

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: it requires owner/admin and explains when each provider token should be used by linking providers to enabling specific features. It does not explicitly mention when not to use the tool or name alternatives, but the context is strong enough for an agent to select it 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?

The annotations already flag destructive behavior, but the description adds value by explaining that cancellation is cooperative and that terminal jobs reject it. This tells an agent the operation is not forcibly terminating and may depend on job 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 a single sentence with no filler. The core action and the key caveat about terminal jobs are both front-loaded, making it easy for an agent to parse quickly.

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

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

For a two-parameter cancellation tool with destructive annotations and an output schema, the description captures the essential semantics: cooperative cancellation and the terminal-job rejection behavior. It could elaborate on what 'open' means or what happens after cancellation, but nothing critical is missing.

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

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

Schema coverage is 100% for both parameters, so the schema already documents jobId and reason. The description adds no parameter-specific detail, which is acceptable at the baseline given comprehensive schema descriptions.

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

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

The description uses a specific verb ('cancel') and resource ('job'), and adds meaningful nuance: it requests cooperative cancellation and open jobs are the target while terminal jobs reject it. It does not explicitly call out a sibling tool, so it stops 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 description gives clear context: use it for open jobs, not terminal jobs, which reject cancellation. However, it does not explicitly describe alternatives such as job_wait, job_get, or job_report, or state when those would be preferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral nuance beyond annotations: events are ordered, and results are only present when the job is terminal, including revision and artifact download URLs.

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 sentence packs the core action, the exact queryable data, and the terminal-condition nuance without filler or redundancy. The most important information is front-loaded, and every clause earns its place.

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

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

For a single-parameter, read-only, idempotent tool with no output schema, the description is complete. It explains what the endpoint returns, including the terminal-only results qualification, so an agent can correctly invoke it and interpret the response 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?

Schema description coverage is 100%, so the jobId parameter is fully documented in the schema. The description adds no independent parameter-level information beyond referring to 'a job', which is acceptable given the schema already explains the durable ID 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 names a specific action ('Get') and resource ('a job'), then enumerates exactly what the tool returns: status, progress, ordered events, and terminal results. This clearly distinguishes it from sibling tools like jobs_list or job_report, which an agent can infer are broader or differently scoped.

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: whenever a caller needs a job's status, progress, ordered events, or terminal results. It does not explicitly name alternatives or exclusion cases, but the precise return-value list makes intended usage apparent relative to siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds substantial behavioral context beyond annotations: pagination semantics (offset counts records vs bytes), continuation requirements (follow verbatim until complete=true), truncation behavior (oversized record returns reportState=truncated, no silent shortening), and the meaning of distinct states (pending/failed/etc. never mean validation passed). This is rich, non-obvious behavioral disclosure.

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

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

The description is dense but every sentence earns its place. It front-loads the core purpose, then covers section semantics, pagination, continuation, truncation, empty states, and the sibling alternative. It is longer than ideal, but the tool is genuinely complex (10 sections, two pagination modes, continuation protocol), so the length is justified. Minor redundancy: 'no record is silently shortened' restates the truncation behavior already described.

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

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

Given the tool's complexity (7 parameters, 10 enum sections, nested filters, output schema present), the description covers everything an agent needs to call it correctly: section selection, pagination units, continuation protocol, truncation handling, empty-section semantics, state interpretation, and the fallback alternative. The output schema exists, so return-value details are already structured. Nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining how offset/limit behave differently per section (records vs bytes), how filters apply to issues only, and how filterId/artifactId function as continuation pins. It doesn't enumerate every parameter, but the schema already does that; the description clarifies the semantics that the schema leaves implicit.

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: 'Read bounded pages from a completed job's immutable report_json artifact.' It then enumerates the distinct sections and their semantics, which clearly differentiates this tool from siblings like artifact_get and job_get. The title 'Read complete job report pages' is reinforced with concrete detail about what each section returns.

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 this tool versus alternatives: 'artifact_get remains available to download the complete file.' It also gives section-specific guidance ('Default is issues for validation and summary for scene_apply/export'), explains continuation semantics, and clarifies empty-section conditions. This is comprehensive routing guidance.

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

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

Annotations already declare the tool read-only, non-destructive, and idempotent. The description adds pagination and filtering context, but those are also visible from the schema. It does not significantly disclose behavior beyond the structured annotation and schema already provided.

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

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

The description is a single, compact sentence that front-loads the core action and includes the two key filtering capabilities. 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 list tool, the description covers scope, pagination, and filtering. With a full output schema, complete parameter descriptions, and safe read-only annotations, nothing essential is missing; only explicit alternative routing keeps it from being fully 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%, so the parameters are already well documented. The description confirms that projectId and status are filters, but it does not add meaning beyond the existing schema parameter 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 names a specific verb and resource: 'List the deployment's jobs, paginated; filter by project or status.' This clearly distinguishes it from single-job tools like job_get, but it does not explicitly name sibling alternatives, so it falls just short of the top score.

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 its use for browsing jobs and mentions filtering, which gives clear context. However, it does not state when to prefer this over job_get, job_report, or other job-related tools, nor does it explain when not to use it.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior; the description adds meaningful extra context about connection risk, timeout tradeoffs, and the validation-result caveat. 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?

Core behavior and defaults are front-loaded, and every sentence contributes operational value. It is slightly dense with specialized clauses, but not padded.

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

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

Covers behavior, default, limits, alternatives, risks, and key result conditions. With an output schema already present, nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%, and both parameters are already well documented there. The description adds the cold-start rationale for the 90s default but does not need to carry much parameter burden.

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

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

States a specific verb and resource: long-poll a job until a terminal state or timeout. It also clearly differentiates itself from job_get loops and webhooks, so an agent can select it confidently.

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

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

Explicitly says this is 'Cheaper than a job_get loop' and instructs chaining calls or using webhooks_set for longer jobs. This gives concrete when-to-use and when-not-to-use guidance.

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

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

Annotations already declare the mutation/safety profile, yet the description adds substantial non-obvious behavior: deterministic processing, a committed new revision, a durable async job handle, a 2048px cap on generated maps, and profile-gated argument semantics. None of this is recoverable from the annotations or schema. No contradiction with idempotentHint=false — the idempotencyKey is a caller-supplied retry guard, not a tool-level idempotency claim.

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?

Front-loads the core purpose before the pipeline and profile branching, and every clause carries information (flow, cap, alternatives, legacy-vs-v2 gating). It is dense and long, but not padded — a slightly tighter packaging of the options/profile paragraph would help.

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?

An output schema exists, so return values need no explanation, and the description covers the decision-critical elements: prerequisites, alternatives, resolution limits, and profile behavior. The remaining gap is per-option semantics for the nested options object, which neither schema nor description closes.

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 19% across 16 params and a 17-key nested options object, the description must carry the load. It explains meaningful semantics for maskSource, baseRoughness/maskRoughness, baseColor, emboss, profile, and roles, but leaves tiling, packing, seamMode, alphaMode/cutoff, normal conventions, displacementMode, and physicalCoverageMeters entirely to the bare schema. Partial compensation, not full.

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

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

States a specific verb and resource ('turn ONE uploaded image into a full PBR material') and adds a distinguishing constraint ('deterministic, no AI'), which separates it cleanly from sibling material_from_maps and asset_import. An agent knows exactly what this produces without opening the schema.

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

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

Gives an explicit prerequisite pipeline (upload_create → PUT → upload_complete → material_from_image) and an explicit exclusion with a named alternative: for 4K label/print work use asset_import instead. It also states when legacy mask/emboss args apply (only when profile is omitted). This is textbook when/when-not guidance.

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

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

Adds real behavior beyond the annotations: it commits a single revision only after validating all targets, preserves existing UVs, and explains slot semantics (applyToObjects writes slot zero while assignments target explicit slots). Given destructiveHint=true, it arguably under-discloses what material slots are overwritten, but the atomicity and UV-preservation notes are substantive context.

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

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

Four dense sentences, front-loaded with the creation verb and source options before moving to placement and commit semantics. Little waste, though the final sentence about returning a durable job is partly redundant given an output schema exists.

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 14-parameter, nested, destructive mutation, the description is only partially complete: it explains sources, slots, and atomic commit, but leaves nearly the whole `options` surface undocumented and does not warn about the destruction implied by destructiveHint=true. Output behavior is covered by the output schema, so the return sentence need not carry weight.

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 7% across 14 parameters with a deeply nested `options` object (~20 sub-fields), and the description covers just a handful (textureJobId, role-labeled images, applyToObjects, assignments). The bulk of the configuration surface (tile, packing, seamMode, normalConvention, physicalCoverageMeters, etc.) is left entirely to bare schema names.

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

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

States a specific verb+resource (create a material) and names the two accepted sources (a completed textureJobId or validated role-labeled images), which is more than a restatement of the title. It does not, however, explicitly distinguish itself from close siblings such as material_from_image or material_recipe, so the agent must infer the boundary.

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 only implied through the source precondition ('completed textureJobId', 'validated role-labeled images'), which hints at when the tool is applicable. There is no explicit when-to-use/when-not guidance and no named alternative for the adjacent cases (material_from_image, material_recipe).

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 and idempotentHint, so the description's 'Read-only' is redundant. However, it adds meaningful scope: 'no project, job or compute' and the paging behavior ('pages of at most 24'), which are not present in annotations. These additions give agents a clearer behavioral model.

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 with no filler. The core function is front-loaded, followed by safety scope and then usage context. Every sentence adds value and the structure is easy to scan.

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

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

There is no output schema, so the description carries the burden of explaining return relevance. It does mention that node selection returns 'pinned Blender input/output indices and enum properties' and that search returns pages, which is useful. It is reasonably complete for a read-only discovery tool, though offset behavior and response structure could be more explicit.

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 describes `node` and `query`, but `limit` and `offset` have no descriptions. The description adds some meaning: 'pages of at most 24' clarifies limit, and 'select one node' clarifies the node parameter. However, `offset` is never explained, and the description does not fully compensate for the 50% schema coverage 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 opens with a specific action and resource: 'Search supported shader aliases/native names in pages of at most 24, or select one node for pinned Blender input/output indices and enum properties.' It clearly differentiates the two modes (search vs. select) and relates the tool to material_recipe and scene_apply, making its role distinct from 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?

It explicitly states when to use the tool: 'Use the alias and exact sockets when editing a material_recipe proposal or scene_apply graph.' It also gives exclusions with 'no project, job or compute,' clarifying what the tool is not for. This provides clear guidance without needing to name 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world, and the description is consistent with all of them. It adds genuinely new behavior: the output is a proposal of scene_apply operations rather than applied mutation, prompts are enhanced but never sent to an image provider, and validation checks are included. This is meaningful disclosure beyond the annotation set.

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 dense sentences, front-loaded with the return type and material families, followed by controls and then the read-only constraint. No filler, though the middle sentence packs a lot of capabilities into one clause chain.

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 25-parameter tool with nested source objects and no output schema, the description establishes the return shape (scene_apply operations), the proposal-only nature and the main control axes. Remaining gaps are minor given the schema carries the per-field detail and no output schema exists to explain.

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 25 parameters at only 48% schema description coverage, the description must compensate, and it does so at a high level by naming the control axes (scale, seed, finish, tint) and the hybrid-graph sources (existing image nodes, explicitly aligned color variant). It maps well onto featureScaleMeters, seed, roughness, tint, the *_Source objects and variantAlignmentConfirmed, though it leaves many individual parameters to 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?

States a specific verb+resource: it returns deterministic editable scene_apply operations for named material families (weathered wood, brushed/painted metal, stone, fabric, image weathering). It also exposes the hybrid-graph capability, which helps distinguish it from the material_from_image/material_from_maps siblings, though it never names those alternatives explicitly.

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 'Proposals only: no scene mutation, image-provider call, baking or Blender compute' sentence tells the agent the boundary of the tool, and hybrid graphs are framed as reusing existing image nodes. However, no sibling is named and no condition is given for choosing this over material_from_image, material_from_maps or material_nodes, so the when-to-use guidance is implied rather than 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds the account-membership scoping and the fact that each entry includes the caller's role, which is useful behavioral information 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?

A single concise sentence that front-loads the action and resource and then adds the key behavioral detail (role in each organization). Every word contributes value.

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

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

For a zero-parameter, read-only listing tool with an output schema and strong annotations, the description fully conveys what the agent needs to invoke it correctly. Nothing important is missing.

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

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

The tool has zero parameters, so the schema leaves nothing to document. The description accurately implies that no arguments are needed to call it; there is no parameter information for the description to supplement.

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 names the exact resource ('organizations'), the action ('List'), and the account-scoped membership context, so an agent can distinguish it from the many other list tools in the sibling set. It also adds the 'role in each' detail, which goes beyond the title.

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

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

The description makes it clear that this is the tool for enumerating the organizations the current account belongs to. There is no sibling organization tool to contrast with, so the absence of an explicit 'use X instead' statement is acceptable; the resource scope alone routes 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value beyond that by disclosing the live snapshotPolicy behavior ('returns the versioned live snapshotPolicy when cached tool descriptions differ') and the set of metrics it reports. It does not elaborate on error conditions or the exact format, but the annotations and output schema mitigate that gap.

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 primary purpose and scope front-loaded in the first sentence, and the key usage instruction in the second. There is no filler; every clause conveys necessary information about capabilities, the snapshotPolicy feature, and the recommended call timing.

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 zero-parameter status check with an output schema present, the description covers the essential context: what is being checked, why it is useful (fail-fast), and the special snapshotPolicy behavior. The output schema presumably documents the return structure, so the description does not need to duplicate that. Nothing an agent needs to decide to call this tool is missing.

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

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

The tool has zero parameters, so schema coverage is trivially 100% and there is nothing for the description to explain. The description focuses on what the tool reports rather than inputs, which is appropriate. The baseline for a 0-parameter tool is 4, and no deduction is warranted since the description adds no parameter-related noise.

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 verb ('Check') and a specific resource ('what the account can do right now'), then enumerates the concrete things it reports: Blender execution availability, compute budget usage, open job counts, deployment policy limits, and the versioned snapshotPolicy. This makes it unambiguous and distinct from the many sibling tools that target specific resources (e.g., job_get, deployment_policy_update).

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 an explicit when-to-use instruction: 'Call before queueing work to fail fast.' This tells the agent the precise scenario for invoking the tool and implies it should be used as a preflight check. While it does not name alternatives, its role is unique among siblings, and the directive is actionable and clear.

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

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

Annotations declare destructive=true/non-idempotent, and the description adds real behavioral context beyond them: presets compile to validated scene operations, write a new revision, and that lighting/camera rigs are authored against a 2 m reference at 800-1500 W and 4-6 m. It doesn't explain the destructive/linear-history implication of the write (that is left to the baseRevisionId schema text), so it stops short of 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?

Front-loaded with purpose, then organized by preset family, with the highest-risk caveat (small-subject white frame) clearly stated. The vivid 'white frame' line and the 42 mm arithmetic are dense but genuinely load-bearing; the passage is slightly longer than strictly necessary but no sentence is disposable.

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

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

For a mutation tool with an output schema and partial annotation coverage, the description supplies the missing context an agent needs: what each preset family changes, the scaling contract for subjectSizeM, and the default state when it is omitted. Return-value behavior is delegated to the output schema, so nothing material is missing.

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

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

Schema coverage is only 56%, and the description compensates by mapping otherwise-undocumented parameters to behavior: 'tint via color, assign via applyToObjects' explains two of the bare schema properties. subjectSizeM's rescaling rule is reinforced, but materialName and the interaction of preset type with per-parameter validity remain unaddressed.

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 first sentence gives a precise verb+resource ('Apply a curated preset as a new revision') plus a parenthetical on what that produces ('compiles to validated scene operations'). It then enumerates the four preset families and their distinct effects, which lets an agent separate this from scene_apply, material_recipe, or presets_list without opening a schema.

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

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

The description gives concrete when-to-use guidance for the key parameter ('Pass subjectSizeM and the whole rig is rescaled for you') and an explicit failure mode for omitting it on small subjects. It does not name sibling alternatives (presets_list for discovery, scene_apply for raw ops) or state preconditions, so it falls short of full routing guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate the safety profile. It adds useful context about what kinds of presets exist, but it does not disclose additional behavioral details such as filtering semantics or output size.

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 dense sentence with a colon-led enumeration. The main action and scope are front-loaded, and every clause adds useful information 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?

With one optional parameter, a rich enum schema, and an output schema present, the description is mostly complete for selecting and invoking the tool. It could slightly improve by explicitly noting when this tool should be used in a preset_apply workflow, but little critical information is missing.

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

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

Even though schema coverage is 100%, the description enriches the 'kind' parameter by mapping each enum value to concrete examples like PBR materials, studio three-point, hero three-quarter, and draft render profiles. This is meaningful value beyond the schema's fairly terse parameter description.

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 ('List') and concrete resource ('curated one-call presets for preset_apply'), then enumerates the four preset kinds. This is specific and clearly distinguishes presets_list from sibling preset_apply and other list-like 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 phrase 'for preset_apply' clearly signals the intended workflow: list available presets before applying one. It provides clear context, though it does not explicitly state when not to use this tool or name alternative tools beyond preset_apply.

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 asynchronous behavior (returns a job handle), the need to share the URL before waiting, the polling requirement, and the default preview behavior for empty templates. Since annotations are all false (no readOnly, idempotent, etc.), this fills the gap with essential behavioral context.

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

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

The description is longer than typical but each sentence contributes value, starting with the core action, then returns, usage instructions, and template specifics. It is logically structured and front-loaded with the primary purpose.

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

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

For a tool with async job creation, liveUrl, and preview generation, the description covers all necessary context: how to use the URL, polling, and template edge cases. The output schema likely handles return structure, and the description leaves no major gaps for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful context beyond the schema: it explains that template=empty skips preview by default and that generatePreview overrides it, adding nuance not present in the schema's property 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 opens with 'Create a project from a template', clearly stating the verb and resource. It then details the return values (liveUrl, job handle) and distinguishes from sibling tools like project_update or project_delete by focusing on creation from a template.

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

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

Provides explicit post-call instructions: share the liveUrl immediately as a Markdown link, mention sign-in, poll job_get, and explains when to expect the first revision. It also clarifies the template=empty behavior and how generatePreview overrides it, giving an agent clear guidance on when and how to use the 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 destructiveHint=true and readOnlyHint=false, so the description adds value by specifying the nuanced behavior: it is a soft-delete, revisions are retained, and open jobs block the operation. This goes beyond the simple destructive flag and informs the agent about consequences and prerequisites.

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 action and its key effects, followed by the critical prerequisite. Every clause carries information without 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 2-parameter destructive tool with an output schema and annotations, the description covers the main behavioral constraints (soft-delete, blocking condition, cancellation path). It does not mention auth or rate limits, but those are typically outside description scope; the essential call-time knowledge is present.

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 (projectId, confirm) are already documented in the schema. The description does not add additional parameter-level meaning, so the baseline 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 states a specific action ('Soft-delete'), the resource ('a project'), and the behavioral effect ('hidden from listings; revisions retained'). This clearly distinguishes it from other delete tools like deployment_delete or integrations_delete, and clarifies it is not a permanent deletion.

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

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

The description gives an explicit precondition ('Open jobs block deletion') and directs the agent to a sibling tool for the required workaround ('cancel them first with job_cancel'). It implies when to use it (when no open jobs exist) and when not to, with a concrete alternative.

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 readOnly, idempotent, and non-destructive. The description adds meaningful behavioral context beyond the annotations by enumerating the returned metadata categories and clarifying that the liveUrl lets signed-in organization members watch progress without starting Blender work. This enriches the agent's understanding of what the operation actually returns.

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 front-loads the core action ('Get project metadata') and then uses a colon-delimited list of concrete return items. Every element contributes information, 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?

Given the tool has a single required parameter, a full schema for that parameter, an output schema, and safety annotations, the description is nearly complete. It covers the main metadata categories and the special liveUrl behavior. It could be slightly more complete by noting when to prefer this over related read tools, but nothing essential for correct invocation is missing.

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

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

There is only one parameter, projectId, and the schema describes it fully with 100% coverage. The description adds no additional parameter-level guidance, but since the schema already provides complete meaning, the 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 uses a specific verb ('Get') and resource ('project metadata') and enumerates the concrete data returned: head revision, recent revisions, active jobs, preview artifact, policy limits, and a liveUrl. It is clear what the tool does, though it does not explicitly contrast itself with the sibling projects_list or project_update.

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 this is for retrieving detailed metadata for a single project as opposed to listing projects, but it never states when to use project_get versus projects_list, artifact_get, or job_get. No explicit alternatives or exclusions are provided, leaving the usage context to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds behavioral context: newest-first ordering and cursor pagination. The cursor schema description adds important behavior (opaque token, verbatim copy, rejection of offsets), which goes beyond annotations.

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

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

The description is a single sentence that front-loads the core purpose and ordering, then adds pagination. The schema parameter descriptions are detailed but each sentence earns its place, especially the cursor warning which prevents a common misuse.

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 read-only list tool with an output schema, the description plus annotations fully cover what an agent needs: what it returns, ordering, pagination mechanics, and safety. The cursor guidance is especially complete, even distinguishing from offset-paginated siblings.

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 specifying ordering and pagination behavior, and the cursor parameter description in the schema is unusually rich: it explains what the token is, how to use it, and contrasts with other tools. This pushes it above 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 states a specific verb ('List'), a resource ('the account's projects'), and an ordering ('newest first') with pagination. It clearly distinguishes this from sibling tools like project_get (single project) and projects_list is the only list-projects tool, so no ambiguity.

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: to list projects. It doesn't explicitly name alternatives or exclusions, but the sibling set includes project_get, project_create, project_update, project_delete, so the list purpose is clear. The cursor parameter description adds usage guidance by warning against treating it as an offset and referencing jobs_list as similarly keyset-paginated.

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 destructive/non-read-only operation, and the description adds useful context by explicitly stating that history, revisions, and jobs are unaffected. It goes beyond annotation hints without contradicting them, though it does not detail any other side effects or permissions.

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

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

Two short sentences front-load the core action and then add the most relevant side-effect clarification. There is no redundant wording or filler, so every sentence earns its place.

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

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

For a simple two-parameter rename operation with a complete input schema, output schema, and annotations, the description is sufficient. It tells the agent what the operation does and which data is preserved, leaving no critical gap for correct invocation.

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

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

Schema description coverage is 100%, so the schema already explains both 'name' and 'projectId'. The tool description adds no parameter-level semantics beyond what the schema provides, so the 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 uses a specific verb and resource, 'Rename a project', and clarifies scope by stating that history, revisions, and jobs are unaffected. This distinguishes it from destructive siblings like project_delete and from project_create/get/list, making the tool's 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 implies the tool is for renaming and reassures that history, revisions, and jobs are unaffected, which gives some context about safe usage. However, it does not explicitly state when not to use it or mention alternatives such as project_create or project_delete, leaving usage guidance largely implicit.

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?

Despite minimal annotations (all hints false), the description discloses key behaviors: output is an immutable artifact downloadable via artifact_get, inputs must belong to the project/deployment, audio must be PCM16 44.1 kHz mono/stereo, clipping is rejected with a directive to lower gainDb, output streams/timing are verified, and the return is a durable job handle. It also states the 600-frame limit and concat-safety of parallel segments. This goes well beyond what annotations provide.

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?

Every sentence in the description adds non-obvious, actionable information: engine tradeoffs, prerequisite ordering, job limits, parallelization strategy, artifact immutability, audio constraints, rejection behavior, verification, and return type. Despite its length, there is no filler or repetition, and it is appropriately front-loaded with the core purpose.

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

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

Given 12 parameters, no output schema, and minimal annotations, the description is exceptionally complete. It covers prerequisites, engine selection criteria, operational limits, parallel scaling, artifact lifecycle, audio input validation, failure mode, verification, and return contract. The only minor omissions (explicit sibling differentiation, per-parameter detail for resolution/fps) are largely compensated by schema defaults and clear parameter names.

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 only 25% schema description coverage, the description carries the burden of explaining parameters. It richly explains the engine enum and audioTracks semantics (startSeconds, sourceOffsetSeconds, gainDb, looping), plus frame-range implications. However, it leaves fps, width, height, samples, and cameraId entirely implicit, relying on parameter names. That partial compensation yields a middle score.

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

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

The description opens with a clear, specific verb and resource: 'Render a frame range to an H.264 MP4.' It also distinguishes internal engine modes, giving it a concrete scope. However, it never explicitly contrasts itself with sibling tools like render_create or render_turntable, so an agent must infer differentiation from the name and context.

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

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

The description gives explicit when-to-use guidance for each engine (cycles_cpu for photoreal, lit_preview for review at 10x lower cost, preview_fast for shape-only) and a prerequisite ('Animate first... via scene_apply animation.*'). It also advises splitting long sequences into parallel contiguous ranges. But it doesn't name alternative tools or state when not to use this tool versus a sibling, so it stops short of full exclusion 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?

With all four annotations false, the description carries the full behavioral burden and delivers abundantly: fan-out clamping to maxConcurrentJobs, the approval round-trip threshold, OpenImageDenoise with adaptive sampling making samples a ceiling, render-only object hiding with 'no revision and nothing to undo,' the durable job handle and immutable PNG, and the validation precondition for purpose=final. The non-destructive hiding claim aligns with destructiveHint=false; no contradiction 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?

Well front-loaded: the one-sentence purpose leads, then organized blocks cover engine selection, fan-out, approval, denoising, hiding, and validation. It is long, and the shards/engine content partially duplicates the schema's parameter descriptions, but each paragraph adds operational context the schema lacks, so the length is largely earned.

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 14-parameter mutation tool with no output schema and neutral annotations, the description covers engine trade-offs, concurrency behavior, approval gating, validation prerequisites, the durable job-handle return value, and the non-destructive hiding idiom. Nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is only 43%, and the description compensates for the highest-risk parameters: purpose (draft vs final validation gating), hideObjectIds/hideNamePattern (render-only, no undo, with a concrete debugging example), samples (denoise ceiling behavior), and engine (use-case framing beyond the enum). A few low-risk parameters like transparentBackground and cameraId are left to self-evident schema fields, so it falls just short of a perfect 5.

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 opening sentence 'Render a still PNG from a revision through the active camera' names the verb, resource, output format, and camera path in one clause. The word 'still' cleanly differentiates it from siblings render_animation and render_turntable without needing to name them.

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?

Gives explicit when-to-use guidance per engine: 'Use it to judge a material or a light rig, and use Cycles for final appearance or transmission checks,' and states preview_fast 'only answers questions about shape and layout.' It also spells out the full purpose=final workflow: wait for validation, read the job_report, repair/revalidate, then pass the proof — including the exclusion that render_create 'never starts validation automatically.'

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