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 the risk and maturity labels ('Risk: read; maturity: L3') and notes that per-request argument checks and session policy still apply, which is mild additional context. 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 short and front-loaded with the command name and risk label. Every sentence earns its place, though the first sentence is essentially a restatement of the tool name and 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, idempotent list operation with an output schema and no required parameters, the description is mostly adequate. The main gap is that it never explains what is being listed or what the output represents, which an agent needs to know to interpret the result correctly.

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

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

Schema description coverage is 75%, and the four parameters are all harness infrastructure fields (`_requestId`, `_authorization`, `_transactionId`, `_expectedSceneRevision`) that are already described in the schema. The description adds no parameter-level meaning, but the schema carries the burden, so baseline 3 is appropriate.

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

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

The description identifies the command as `animation.action_list` and labels it a read operation, but it never states what the tool actually does—what actions are being listed, from where, or what the output contains. The name and title imply 'list animation actions,' but the description itself is vague about the resource and result.

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 no guidance on when to use this tool versus alternatives. It mentions that per-request argument checks and session policy apply, but that is a generic harness requirement, not usage guidance. Among the many animation-related siblings, there is no indication of when `animation.action_list` is the right choice.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint all false allowed. The description adds 'Risk: standard; maturity: L3' and generic policy requirements, which gives minimal extra context but does not disclose actual behavior, side effects, or what the cleaning operation modifies.

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 short, but the first sentence redundantly repeats the tool name. The metadata sentence is factual but does not help an agent understand the operation, so the limited word count is not used productively.

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

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

For a tool with 9 parameters)Skip no description of purpose, usage, or behavior, this is severely incomplete. An agent cannot infer what cleaning an F-curve means, which parameters matter, or what output to expect, despite the presence of an output schema.

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

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

Schema description coverage is only 33% (only internal fields like _requestId and _transactionId have descriptions). The description does not explain any parameters such as dataPath, threshold, objectId, or name, and does not compensate for the large number of undocumented arguments.

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 only states 'PartMe Blender Harness command `animation.fcurve_clean`' followed by risk, maturity, and requirements metadata. It does not state what the tool does, provide a specific verb, or describe the resource being acted upon. This is essentially a restatement of the tool name without any functional meaning.

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?

There is no guidance on when to use this tool versus alternatives like blender_animation_fcurve_edit or blender_animation_action_list. The phrase 'Per-request argument checks and session policy still apply' describes general harness requirements, not selection criteria or context of use.

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

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

The description discloses only risk and maturity levels, which are unrelated to behavioral traits like side effects, data modification, or reversibility. Annotations indicate readOnlyHint=false, destructiveHint=false, etc., but the description adds no meaningful context about what the tool actually does to the scene, such as whether it modifies keyframes, requires specific permissions, or has side effects. Since annotations are all false, the description carries the full burden, which it fails to meet.

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 extremely short, which could be considered concise, but it is underspecified rather than efficiently conveying necessary information. It front-loads the command name but provides no functional content. This is under-specification, not appropriate conciseness, so a score of 2 reflects the lack of substance.

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

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

Given the tool's complexity (13 parameters, output schema present) and the need to differentiate from many sibling animation tools, the description is completely inadequate. It lacks any explanation of the tool's purpose, usage, parameter meanings, or expected behavior. An agent would be unable to call this tool correctly based on the description alone, even with the schema, because it doesn't know what the operation does.

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

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

The description provides no information about any of the 13 parameters. Schema coverage is only 23% (descriptions exist for _requestId, _authorization, _transactionId), and the description does not compensate for the remaining parameters. Without any explanation of dataPath, name, timeScale, interpolation, etc., an agent has no help understanding their semantics beyond the raw schema types.

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 merely restates the tool name ('PartMe Blender Harness command `animation.fcurve_edit`') and adds generic metadata (risk, maturity, requirements). It does not state what the tool actually does, such as editing animation F-curves, nor does it distinguish it from sibling tools like blender_animation_fcurve_clean or blender_animation_insert_keyframe. This is a tautology, offering no functional clarity.

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?

There is no guidance on when to use this tool versus alternatives. The description mentions 'Requirements: Per-request argument checks and session policy still apply' but that is a generic policy note, not usage context. It fails to indicate typical use cases, preconditions, or exclusions.

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

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

Annotations already indicate this is not read-only, not idempotent, not open-world, and not destructive. The description adds only generic 'Risk: standard; maturity: L3' and a reminder that session policy applies, which is process metadata rather than a disclosure of what the operation actually does to the Blender scene, the target object, or the animation data.

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

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

The text is short, but it is under-specified rather than concise. It spends its sentences on boilerplate ('Risk: standard; maturity: L3') and a tautological command identifier instead of front-loading a meaningful statement of what the command does and its key constraints.

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

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

With 7 parameters, 4 required, and multiple closely related animation tools in the sibling list, this description is far too thin. It omits the command's purpose, how to specify the animation property, expected frame semantics, and any caveats about the session or transaction requirements, leaving an agent unable to invoke the tool correctly without external knowledge.

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 43%, covering only the _requestId, _authorization, and _transactionId metadata parameters. The core parameters dataPath, frame, object, and _expectedSceneRevision have no schema description, and the tool description adds no meaning for them. An agent cannot tell what dataPath should look like, how frame is interpreted, or what object references are valid.

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 only restates the tool name ('PartMe Blender Harness command `animation.insert_keyframe`') without stating what the tool does, such as which animation property it inserts or on what object. The title implies 'insert keyframe', but the description itself is a tautology of the name, not an explanation of behavior.

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?

There is no guidance about when to use this tool versus siblings such as blender_animation_pose_keyframe, blender_animation_shape_key_keyframe, or blender_animation_fcurve_edit. The description only says 'per-request argument checks and session policy still apply,' which is generic harness boilerplate and does not help an agent choose this tool over alternatives.

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

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

The description only contributes risk and maturity metadata ("Risk: standard; maturity: L3") and a generic policy reminder. It does not disclose the behavioral effect of the command, any side effects, state mutations, or operational requirements. Annotations are all false and offer no safety profile, so the description carries the full burden and fails to meet 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 short, but this is under-specification rather than purposeful conciseness. It front-loads only identifying and policy boilerplate, with no functional information, so the brevity does not serve the agent.

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

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

For a parameter-heavy command with low schema coverage and no behavioral description, the definition is severely incomplete. It lacks operational meaning, parameter guidance, and any context about expected outcomes or side effects, despite having an output schema and numerous sibling tools to differentiate from.

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 only 33% and 12 parameters, the description needed to compensate by explaining key fields like action, name, start, track, or objectId. It does not mention any parameter, leaving the agent to guess at semantics for most of 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 only states "PartMe Blender Harness command `animation.nla_add_strip`", which restates the tool name and title without saying what the command does. It never identifies the operation (adding an NLA strip) or the resource it affects, so an agent cannot determine the tool's purpose from the description alone.

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?

There is no guidance about when to use this tool versus alternatives such as blender_animation_insert_keyframe, blender_animation_action_list, or other animation tools. The generic note about per-request checks and session policy provides no decision-relevant context.

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

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

No behavioral traits are disclosed beyond the annotations, which are all false. 'Risk: standard' and 'maturity: L3' do not describe side effects, required scene state, or transaction behavior, so the agent remains blind to what invoking this tool changes.

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 short, but brevity is achieved by omitting substance rather than by tight, informative prose. A single sentence of metadata does not earn its place because it does not help select or call the tool.

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

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

For a 9-parameter command with nested objects and no behavioral annotations, the description is radically incomplete. It lacks purpose, parameter semantics, prerequisites, and any indication of side effects, so an agent cannot safely invoke 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?

With only 44% schema description coverage and no parameter explanation in the description, key parameters like armature, bone, dataPath, and frame are left effectively undocumented. The description does nothing to compensate for the schema 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 only restates the command name (`animation.pose_keyframe`) and adds risk/maturity metadata; it never states what the tool does, making it effectively a tautology rather than a functional definition.

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

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

No guidance is given on when to use this tool versus alternatives such as blender_animation_insert_keyframe or blender_animation_shape_key_keyframe. The mention of session policy is an operational constraint, not a usage guideline.

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

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

Annotations are all false but provide no safety profile, and the description does not compensate. There is no mention of whether retargeting mutates the scene, what gets changed, whether it can be reverted, or how it interacts with transactions; 'Risk: standard' and 'maturity: L3' are generic metadata, not 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 short, but brevity is not conciseness when none of the sentences earn their place. Every sentence is either a restatement of the title or generic boilerplate that would apply to any harness command; no useful information is front-loaded.

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

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

With 10 parameters, required nested objects, and no explanation of the retargeting operation, the description is far from complete. An agent has no way to construct a valid call, understand the expected boneMap shape, or interpret the frame range semantics, making this inadequate despite the presence of an output schema.

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

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

Schema description coverage is only 40%, and the description adds zero parameter-level meaning. Crucial parameters like source, target, boneMap, frameStart, and frameEnd are left unexplained, and the description does not clarify what these objects/values mean in the context of retargeting.

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 only restates the tool's command name ('PartMe Blender Harness command `animation.retarget`') and adds generic risk/maturity labels. It never states what retargeting does, what assets it operates on, or what outcome it produces, so an agent cannot tell this apart from the many other animation 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?

No guidance is given about when to use this tool versus alternatives such as blender_animation_fcurve_edit, blender_animation_pose_keyframe, or other animation tools. The only usage-related sentences are generic harness policy statements that apply to every command.

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

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

Annotations are all false (readOnlyHint=false, destructiveHint=false, etc.), so the description must clarify that this is a mutating operation that changes the animation frame range. It does not mention any side effects, what state is modified, or any required context. The 'Risk: standard' line is not behavioral disclosure. No contradiction, but no added transparency.

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

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

The description is very short (two sentences), but this is under-specification rather than conciseness. The content is mostly boilerplate about risk and requirements, which does not earn its place. No front-loaded functional explanation.

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 6 parameters, including required 'start' and 'end', the description is completely inadequate. It fails to explain what the tool does, what the parameters mean, or what the output represents (though an output schema exists, it is not enough without a functional description). An agent cannot safely invoke this tool based on the description.

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

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

The description provides zero information about the parameters 'start' and 'end' (which are likely the core inputs). Schema coverage is 50%, and the description does not compensate for the undocumented parameters. An agent has no idea what values to pass or what units/format are expected.

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 only identifies the command name 'animation.set_frame_range' and calls it a 'PartMe Blender Harness command'. It does not state what the tool does, such as setting the start and end frames of an animation. This is essentially a tautology, restating the title without adding functional meaning.

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 'Requirements: Per-request argument checks and session policy still apply' but gives no guidance on when to use this tool versus alternatives like blender_playback_set_frame or other animation tools. There is no mention of scenarios, prerequisites, or exclusions, so an agent cannot decide when to call 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 signal that this is a non-read-only, non-idempotent, non-destructive mutation (all hints false). The description adds only boilerplate risk/maturity and policy statements, disclosing nothing about side effects, duplicate-name behavior, transaction requirements, or what happens to existing shape keys. No contradiction with annotations, but the added behavioral context is minimal.

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 short and readable, with a reasonable structure (command identifier, then risk/maturity, then requirements). However, brevity here comes at the cost of substance — every sentence is present, but none of them communicate what the tool does or how to call it.

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 8-parameter mutation tool with a required keyName, a boolean fromMix, and an objectId targeting selector, the description is far too thin. An agent has no idea what operation occurs, what keyName should be, what fromMix controls, or how this differs from the sibling shape_key_keyframe tool. The presence of an output schema does not compensate for missing operation semantics.

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% (only _requestId, _authorization, _transactionId are documented). With coverage this low, the description must compensate, but it says nothing about keyName (required), fromMix, objectId, or name. The required keyName — the one parameter every caller must provide — has zero semantic explanation in either the schema or the 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 merely restates the command name (`animation.shape_key_add`) and labels it as a 'PartMe Blender Harness command' — a tautology that adds no functional meaning. It never states what the tool does (e.g., creates a shape key on a mesh/object) and does not differentiate it from nearby siblings like blender_animation_shape_key_keyframe.

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?

There is no guidance on when to invoke this tool versus alternatives such as shape_key_keyframe, insert_keyframe, or object-related creation tools. The only operational notes ('Risk: standard; maturity: L3' and 'Per-request argument checks and session policy still apply') are policy metadata, not usage direction or exclusions.

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

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

No annotation contradiction exists: readOnlyHint, openWorldHint, idempotentHint, and destructiveHint are all false, and the description does not claim otherwise. However, the description adds only generic risk/maturity/session-policy metadata and no concrete behavioral detail such as whether an existing shape key is required, what scene mutations occur, or how the keyframe is applied.

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 short but this is under-specification, not effective conciseness. The sentence is mostly boilerplate and does not earn its place because it conveys no operational content about the tool's purpose, inputs, or effects.

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 nine parameters, four required ones, a broad sibling list of animation and shape-key tools, and no meaningful description, the definition is far from complete. Even though an output schema exists, the agent still lacks the basic information needed to decide when to call this tool and how to construct a correct request.

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

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

The description provides no explanation of any parameter. Schema description coverage is only 44%, so the description needed to compensate, but it does not clarify frame, keyName, objectId, value beyond what the schema already says, or the transaction/revision fields. An agent is left to guess the meaning and relationship of the required parameters.

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

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

The description is essentially a tautology: it restates the command name 'animation.shape_key_keyframe' without any verb, resource, or outcome. An agent cannot tell from the description whether this creates, edits, removes, or queries a shape key keyframe, and it does not distinguish it from siblings like blender_animation_insert_keyframe or blender_animation_shape_key_add.

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?

There is no guidance about when to use this tool versus the many animation-related siblings. The only usage-related text is generic boilerplate about 'per-request argument checks and session policy', which says nothing about the conditions that should lead an agent to invoke this specific command.

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, the description discloses a gated risk level, mandatory local user approval, a self-approval prohibition, retry behavior using the same request id, and that per-request argument checks and session policy still apply. This meaningfully enriches the agent's model of how the command behaves during execution.

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

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

The description is compact at three sentences and front-loads the command identity before packing in risk, approval, and retry details. The first sentence is somewhat redundant with the tool name, but the rest is dense and without 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 destructive, user-gated command with 7 parameters and low schema coverage, the description is incomplete. It covers the approval/retry workflow well but omits the core purpose, the meaning of most parameters, and any guidance for selecting among asset-related siblings. The output schema may cover return values, but an agent still lacks enough context 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 description coverage is only 43%, so the description must compensate, but it does not explain providerId, url, filename, _transactionId, _expectedSceneRevision, or _authorization. The only indirect connection is 'same request id', which maps to _requestId, but that is far too thin for a 7-parameter destructive tool.

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

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

The description mostly restates the command name ('PartMe Blender Harness command `asset.fetch_generated`') and then moves to risk and approval mechanics. It never states what the tool actually does—what 'generated' means, what it fetches, or what side effect it has in Blender—so an agent cannot distinguish it from siblings like blender_asset_fetch_url or blender_asset_import_file.

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 useful workflow guidance: local user approval is required, clients cannot self-approve, and the same request id must be retried after approval. However, it does not explain when to use this tool versus alternatives, nor does it state the conditions or scenarios that select this command over other asset-fetching 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 are all false, so they do not clarify side effects. The description adds only 'Risk: standard; maturity: L1' and a session-policy caveat. It does not disclose whether the tool downloads from the network, writes files, modifies the current scene, or has other behavioral implications.

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 text is short but does not earn its place: it repeats the command name and spends words on generic risk and maturity labels. This is under-specification rather than effective conciseness, with no front-loaded functional statement.

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 six parameters, an output schema, and many closely related asset-fetching siblings, the description is far too thin. An agent cannot determine what the tool does, when to call it, what the parameters mean, or what the outcome will be.

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 50%, and the key parameters `url` and `filename` have no schema descriptions. The tool description provides no parameter meaning at all, so it fails to compensate for the gaps or add 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 only restates the command name ('PartMe Blender Harness command `asset.fetch_url`') and adds generic risk/maturity boilerplate. It does not explicitly state that the tool fetches an asset from a URL, what the asset is, or how it enters the Blender scene, so it adds no real purpose clarity 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?

There is no guidance on when to use this tool versus siblings like blender_asset_import_file, blender_asset_fetch_generated, or blender_asset_polypizza_download. The note that 'per-request argument checks and session policy still apply' is a generic constraint, not usage guidance.

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

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

The description adds no behavior beyond the annotations: it does not state that import_file mutates the asset library or scene, whether it can fail midway, or what side effects occur. 'Risk: standard; maturity: L3' is metadata, not behavioral disclosure, and the annotations provide no safety profile.

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

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

The description is short and front-loaded, but it spends its sentences on a command identifier and risk metadata rather than user-facing meaning. This is under-specification rather than effective conciseness; no sentence explains what the tool does.

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 five parameters, a nested path object, transaction-related arguments, and an output schema, this description gives the agent none of the needed context. It does not state what value path takes, what _expectedSceneRevision guards, or what the import will do, so a correct call would depend on guessing.

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 60% and the required 'path' parameter is an opaque object with no property details; the description does not compensate by explaining path format or the meaning of _expectedSceneRevision. The schema's descriptions for _requestId, _authorization, and _transactionId are the only semantic info, and the description adds none.

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

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

The description merely restates the command as 'PartMe Blender Harness command asset.import_file' and adds no verb, resource, or effect. It never says that a file is imported into Blender's asset library, so the agent learns nothing beyond the tool name.

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

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

No guidance is given for when to use this tool instead of any sibling such as blender_asset_library, blender_asset_pack_resources, or blender_export_file. The only operational note, 'per-request argument checks and session policy still apply,' is a constraint, not a usage guideline.

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 mentions only 'Risk: standard; maturity: L3' which are opaque classifications, not behavioral traits. The annotations provide no readOnly/destructive/idempotent signals, so the description carries the full burden of explaining side effects, but it offers none.

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

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

It is short, but this is under-specification rather than conciseness. Every phrase is generic and carries no functional content, so the sentence does not earn 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 8 parameters, nested objects, and an output schema, the description is far too minimal. It never explains the operation, what the arguments mean, or what output is returned, leaving the agent to guess from the schema and sibling 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?

Schema coverage is only 38% and the core parameters (dataType, names, path, link) are undocumented. The description adds no meaning to any parameter, which is especially costly for a tool with nested objects and required fields.

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

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

The description only restates the command name `asset.library` with no concrete action or resource. It does nothing to distinguish this tool from sibling asset tools like blender_asset_import_file or blender_asset_pack_resources.

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

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

No guidance on when to use this tool versus alternatives. The only note about 'Per-request argument checks and session policy' is generic and does not help an agent choose between asset-related commands.

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

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

The description adds no behavioral details beyond what annotations already indicate. Annotations mark the tool as non-read-only, non-destructive, and non-idempotent, but the description does not clarify what side effects occur, whether it modifies asset paths in the scene, or any other behavioral consequences. The risk and maturity notes are not behavioral.

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 extremely sparse, with only a mention of the command name, risk, maturity, and generic requirements. It is not front-loaded with useful information; the first sentence is just the command name, which is redundant with the tool name. It lacks substance and structure, making it under-specified rather than concise.

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

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

The description is inadequate for an agent to correctly invoke the tool. It does not explain what the command does, what inputs are meaningful, or what the expected outcome is. While an output schema exists, the description still fails to provide essential context about the operation's purpose and behavior, making it incomplete.

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

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

The description mentions no parameters and adds no meaning beyond the input schema. Schema coverage is 75% (three of four parameters have descriptions), but the description provides no additional context about how parameters relate to the operation. It does not compensate for the missing description of _expectedSceneRevision or clarify the purpose of any parameter.

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

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

The description only states it is a PartMe Blender Harness command and names the command as `asset.make_paths_relative`. It does not explain what the command does, such as converting absolute paths to relative ones. The purpose is vague and relies entirely on the name, which is insufficient for an agent to understand its function.

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

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

No guidance is provided on when to use this tool versus alternatives. It mentions per-request argument checks and session policy, but these are generic requirements, not usage instructions. There is no context about typical scenarios, prerequisites, or when to prefer this over similar asset tools like blender_asset_import_file or blender_asset_pack_resources.

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 carry no hints (readOnly, openWorld, idempotent, destructive all false), leaving the description as the sole source of behavioral disclosure. The description only mentions 'Risk: standard; maturity: L3' and that 'Per-request argument checks and session policy still apply', which are generic operational constraints rather than tool-specific behavior. It does not state whether the tool modifies state, reads data, or has side effects, so behavioral transparency is severely lacking.

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 extremely brief, which might suggest conciseness, but it is under-specified to the point of uselessness. It contains no information that helps an agent decide to use the tool, so it is not effective conciseness; it is omission.

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 specific nature (a Blender harness command) and the absence of annotations, the description is wholly inadequate. It does not explain what 'pack_resources' does, what inputs are meaningful, or what the output schema represents. An agent has no basis to 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 description coverage is 75% (3 of 4 parameters documented), so the baseline is moderate. The description adds no parameter explanations beyond what the schema provides, and critically it does not clarify the undocumented '_expectedSceneRevision' parameter. Thus the description fails to compensate for the schema's gaps and adds no value to parameter understanding.

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

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

The description merely restates the tool name as a command ('PartMe Blender Harness command `asset.pack_resources`') without any explanation of what the command does. It fails to specify a verb, resource, or effect, leaving the agent to infer from the name alone. This is a tautology, not a purpose statement.

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

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

No guidance is provided about when to use this tool versus any of the many sibling tools. There is no mention of context, prerequisites, or alternatives, so an agent cannot determine appropriate invocation conditions.

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

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

The description adds meaningful behavioral context beyond the annotations: the tool is gated, requires local user approval, forbids the client from approving its own request, and retries with the same request id after approval. This is valuable, non-obvious information that helps an agent orchestrate the call correctly.

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 reasonably compact, but the opening phrase 'PartMe Blender Harness command `asset.polypizza_download`' largely restates the tool name and adds little. The approval workflow is front-loaded and clear, but the generic final sentence about requirements adds limited 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 gated, destructive download operation with five parameters, the description is incomplete. It omits what the tool actually does, where the asset comes from, what modelId refers to, and what the expected scene revision means. The approval and retry mechanics are covered, but the core operational context 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 60%, leaving modelId and _expectedSceneRevision undocumented. The description does not explain what modelId should contain or how _expectedSceneRevision relates to the download. It mentions retrying the same request id, which lightly reinforces _requestId, but it does not compensate for the missing parameter semantics.

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

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

The description never states that this tool downloads a PolyPizza asset; it only repeats the command name and explains the approval flow. The actual behavior must be inferred entirely from the tool's name, making this closer to a tautology than a functional explanation.

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

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

No guidance is given about when to use this tool versus related siblings like blender_asset_fetch_url, blender_asset_fetch_generated, or blender_asset_import_file. The approval and retry notes are operational context, but they do not help an agent decide between this tool and alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the 'Risk: read' phrase adds nothing beyond the structured data. However, the description does contribute 'maturity: L1' and the session-policy requirement, which are not present in the annotations. No contradiction exists, but the added behavioral context is thin — nothing about result pagination, rate limits, or search semantics.

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 brief with zero verbosity, so it scores adequately on size alone. However, its short length is spent on low-value content: restating the command name and duplicating the readOnly annotation. It is concise but not information-dense.

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 output schema exists, so return values need not be explained, and annotations cover the safety profile. But the description omits the tool's core purpose, the meaning of its search parameters, and any relationship to the sibling download tool. For a search command with seven parameters, this leaves an agent without enough context to use it correctly.

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

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

Schema description coverage is only 43%, and the three user-facing parameters (query, licence, limit) have no descriptions in either the schema or the tool description. With low coverage, the description was required to compensate, but it mentions no parameters at all. The harness parameters (_requestId, _authorization, _transactionId) are documented in the schema, yet the functional search parameters remain entirely unexplained.

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 is essentially a tautology: it identifies the tool as a 'PartMe Blender Harness command asset.polypizza_search' but never states that it searches the Poly Pizza asset library. The agent must infer purpose from the tool name alone. It does not differentiate this from its close sibling blender_asset_polypizza_download beyond the name difference.

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

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

No guidance is given on when to use this tool versus alternatives such as blender_asset_polypizza_download, blender_asset_fetch_generated, or blender_asset_fetch_url. The only contextual sentence ('Requirements: Per-request argument checks and session policy still apply') states preconditions but says nothing about the search-then-download workflow or when this command is the right choice.

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

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

The description adds only 'Risk: standard; maturity: L3' which does not describe what the operation does or what side effects it has. Annotations already indicate readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the description contributes no meaningful 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 short but not meaningfully concise; it substitutes boilerplate about harness policy for a substantive statement of tool behavior. This is under-specification rather than efficient 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 complex tool with 12 parameters and no rich schema descriptions, the description is grossly incomplete. It never explains what the command does to the camera or scene, what the output contains, or how the parameters relate to the resulting handheld motion.

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 12 parameters and only 25% schema description coverage, the description must compensate by explaining key parameters such as frameStart, frameEnd, seed, noiseScale, rotationStrength, and translationStrength. It does not mention any parameter, leaving agents unable to determine how to configure the handheld effect.

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 only restates the command name `camera.add_handheld` and provides generic harness metadata like risk and maturity. It does not state what adding a handheld camera does, the resource affected, or how it differs from sibling tools such as blender_camera_create or blender_camera_follow_path.

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

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

No guidance is given on when to use this tool versus alternatives. The mention of 'Per-request argument checks and session policy' is generic harness boilerplate and provides no actionable usage context or exclusion criteria.

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

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

Annotations provide no hints, so the description must disclose behavioral effects, but it does not say whether this rotates the camera, moves it, or has side effects on scene state. The phrases 'Risk: standard' and 'maturity: L3' do not meaningfully explain what happens during execution.

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 short, but that brevity is under-specification rather than focused conciseness. Most of the text repeats metadata like harness command identity and generic policy requirements instead of earning its place by explaining the tool's behavior.

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

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

For a 7-parameter camera tool with two target-related inputs, the description provides none of the contextual semantics needed for correct invocation. An agent would still need to reverse-engineer the expected behavior from the name and schema.

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

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

Schema coverage is only 57%, and the description adds no parameter-level meaning at all. It does not clarify how `target` relates to `targetObject`, what `name` refers to, or how the 3-number array should encode a direction or position.

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 only says that this is a PartMe Blender Harness command named `camera.aim_at` and gives risk/maturity metadata; it never states what the command actually does, such as pointing the camera at a target. This essentially restates the command name and leaves the purpose to be inferred from the title and 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?

There is no guidance on when to use this tool versus `blender_camera_create`, `blender_camera_follow_path`, or `blender_camera_add_handheld`. The only usage-related note is a generic session policy reminder that would apply to every harness command.

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 signal that this is not read-only or idempotent, and the description adds only generic notes about risk and maturity. It does not disclose actual invocation effects such as whether a camera object is created, whether duplicated names are allowed, what state changes occur, or how transactions interact with the creation.

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 short, but its words are mostly redundant or generic; 'camera.create' repeats the title, and risk/maturity phrasing could apply to any harness tool. It is under-specified rather than usefully concise, so it does not earn its place.

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

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

Despite an output schema and annotations, this tool has 9 parameters, is mutating, and belongs to a large family of camera/Blender tools; the description is far too thin for an agent to invoke it confidently. An agent would still need to infer the essential behavior and required context from the name and schema alone.

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 prose adds no parameter-level meaning beyond the input schema. With only 56% schema description coverage, several fields like 'lens', 'active', and '_expectedSceneRevision' still have no semantic explanation, and the tool description does nothing to bridge that 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 only says 'PartMe Blender Harness command `camera.create`', which repeats the tool/title rather than explaining that this command creates a Blender camera. It does not clarify how this differs from siblings such as blender_camera_add_handheld or blender_camera_follow_path.

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?

There is no when-to-use or when-not-to-use guidance. The only contextual statement is that per-request argument checks and session policy apply, which is broad policy boilerplate rather than guidance for choosing this tool over its 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?

The description provides no behavioral disclosure beyond what annotations already state. All annotations are false (readOnlyHint=false, openWorldHint=false, idempotentHint=false, destructiveHint=false), so the description carries the full burden of explaining side effects, but it simply does not. 'Risk: standard; maturity: L3' are quality labels, not behavior.

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

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

The description is short, but the sentences do not earn their place. The first sentence only repeats the tool name, and the rest is boilerplate metadata. It is under-specified rather than concise, providing no actionable information for an agent.

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

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

For a tool with 10 parameters, complex nested objects, and no explicit purpose, this description is woefully incomplete. An agent cannot determine what the tool does, how to use its parameters, or what the output will be from this definition. The existing output schema does not substitute for missing usage guidance.

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 40%, with 60% of parameters (camera, frameEnd, frameStart, name, path, _transactionId) undocumented in the schema. The description adds no parameter explanations whatsoever, only a generic reference to argument checks. It completely fails to compensate for the schema gaps.

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

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

The description merely restates the command name (`camera.follow_path`) and gives metadata (risk, maturity) without stating what the tool actually does. It does not mention that it makes a camera follow a path, and does not differentiate from sibling camera tools like blender_camera_aim_at or blender_camera_create. This is essentially a tautology.

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

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

No guidance is provided on when to use this tool versus alternatives. The only hint is a generic note that 'per-request argument checks and session policy still apply,' which does not explain when this function is appropriate or how it compares to other camera tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds 'Risk: read' (duplicate of readOnlyHint), 'maturity: L3' (undefined), and a policy reminder, but these are not behavioral disclosures about what the tool does or returns. It does not contradict annotations, but it contributes little beyond 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 short, but its first sentence is a tautology of the title and wastes the opening. The remaining two sentences add non-essential context (risk, maturity, policy) but omit any substantive explanation. It is under-specification masquerading as conciseness.

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

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

For a 10-parameter tool with an output schema, this description leaves the agent unable to determine what the tool does, what output it produces, or how to select it. It relies entirely on the name 'capability.describe' and provides no actionable context. An agent would have to guess or inspect other resources to use it correctly.

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

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

Although schema description coverage is reported at 80%, most parameter descriptions are placeholders like 'See command validation; detailed type not yet audited', providing no real semantics. The single required parameter `id` is not described. The tool description adds nothing about parameters, so the meaningful coverage is effectively low.

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 only restates the command name ('PartMe Blender Harness command `capability.describe`') without explaining what the tool does. It provides no verb+resource explanation, such as 'Describes a Blender capability' or 'Returns details about a specified capability'. Without that, an agent cannot infer the tool's function beyond its name.

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

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

No guidance is given on when to use this tool versus alternatives like blender_capability_list or blender_session_capabilities. The only usage-related line ('Per-request argument checks and session policy still apply') describes constraints, not selection criteria. There is no mention of prerequisites, exclusions, or typical scenarios.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds risk and maturity context and notes that session policy still applies, which supplements 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 short and front-loads the essential identity and safety classification. The final sentence is generic but harmless. It earns its place by being compact.

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, and annotations cover the safety profile, so the description need not explain return values or safety. However, it lacks a clear statement of function and sibling differentiation. For a capability-listing tool this is barely adequate.

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

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

With 13 parameters and only 69% schema description coverage, the description contributes nothing to parameter understanding. Several parameters are explicitly 'not yet audited' in the schema, and the description does not clarify them or explain how limit, domain, or offset should be used.

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

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

The description states the command name and risk level but never explicitly says the tool lists capabilities. The purpose is inferable from the name but not stated in the description. This is roughly the minimum viable level.

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?

There is no guidance on when to use this tool versus alternatives. The note about per-request argument checks and session policy is a generic constraint, not selection guidance. Siblings like blender_capability_describe and blender_session_capabilities remain undistinguished.

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

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

Annotations are all false (not read-only, not idempotent, not destructive), but the description does not clarify what side effects occur when creating a collection, such as adding it to the scene or respecting a parent. The mention of 'Risk: standard; maturity: L3' and generic session policy adds no behavioral detail beyond the annotation fields.

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 short but not effectively concise; it is under-specified defense. It repeats the command name and adds boilerplate without substantive content. It does not front-load the purpose or key usage facts.

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 six parameters, an output schema, and many sibling collection-related commands, this description does not provide enough context for an agent to know how to invoke it properly. It lacks operation semantics, parameter guidance, and relationships to sibling tools, leaving critical gaps.

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

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

Schema coverage is only 50% (name, parent, and _expectedSceneRevision lack descriptions). The description provides no explanation of what 'name' or 'parent' mean or how they affect the operation. With six parameters alerting an agent, this is insufficient compensation for the incomplete 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 only restates the command name 'collection.create' and adds generic harness metadata. It never explicitly says that this tool creates a collection in Blender, so an agent cannot derive what action is performed. This is a tautology of the title/name.

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?

There is no guidance on when to use this tool versus alternatives like blender_collection_move_object or blender_collection_set_visibility. The only operational notes ('Per-request argument checks and session policy still apply') are generic harness requirements, not tool-specific usage direction.

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 states 'Risk: standard; maturity: L3' and mentions argument checks, but these are generic and not specific to this tool's behavior. With annotations marking all hints as false (no readOnlyHint, no destructiveHint, no idempotentHint), the description fails to disclose that this is a state-changing operation that likely moves an object, potentially removing it from its current collection. It provides no details on side effects, reversibility, or whether the operation is transactional.

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

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

The description is very short, but it is not effective conciseness; it omits essential purpose and usage information. The single sentence provides minimal value, and the risk/maturity tags feel like boilerplate that does not help an agent. It is under-specified rather than concise, earning a low score.

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

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

Given the tool's complexity (8 parameters, no annotations to convey safety, and an output schema that is not described), the description is wildly insufficient. An agent cannot correctly invoke this tool without understanding what it does, which parameters matter, and what side effects to expect. The description fails to provide any of that context, making it dangerously incomplete.

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 only 38%, the description must compensate for undocumented parameters, but it provides zero parameter information. The schema reveals parameters like 'collection', 'name', 'objectId', and 'exclusive', but the description does not explain their meaning or usage. An agent is left to guess what 'exclusive' does or which parameters are required beyond the two required ones.

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 only names the harness command ('collection.move_object') without stating what the tool actually does. It does not mention moving an object between collections, nor does it distinguish from siblings like blender_object_parent or blender_collection_set_visibility. The verb and resource are absent, so an agent cannot infer the tool's core function.

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

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

The description offers no guidance on when to use this tool versus alternatives. It mentions that 'per-request argument checks and session policy still apply' but gives no contextual conditions or exclusions. Without any usage context, an agent cannot determine if this is the right tool for moving an object to another collection.

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

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

Annotations already indicate readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false. The description adds no behavioral context beyond generic risk/maturity labels. It does not explain what changes occur (e.g., visibility flags toggled), whether the operation is reversible, or any side effects. No contradiction, but no added value.

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

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

The description is short and front-loaded with the command name, but the risk/maturity sentence is boilerplate that does not earn its place. It is concise but not informative.

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

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

For a mutation tool with no idempotency and no destructive hint, the description should explain what visibility change is performed and what the boolean parameters control. The output schema exists but the description still fails to provide the minimal context needed to call the tool correctly.

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

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

Schema description coverage is only 43%, and the description does not compensate. The 'name', 'render', and 'viewport' parameters are undocumented in the schema and the description gives no hint that 'render' and 'viewport' control visibility channels. The description adds no parameter meaning beyond the raw schema.

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

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

The description only restates the command name and adds generic risk/maturity metadata. It does not state what the tool does (e.g., toggles collection visibility in viewport/render) or distinguish it from sibling tools like blender_object_set_visibility or blender_collection_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?

No guidance on when to use this tool versus alternatives. The only usage-related statement is 'Per-request argument checks and session policy still apply', which is generic harness boilerplate and does not help an agent decide when to invoke this tool.

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

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

Annotations provide no positive safety signals (readOnlyHint, idempotentHint, destructiveHint all false), so the description must disclose behavior, side effects, and scene mutations. It does none of this; 'Risk: standard' is too vague to inform an agent about actual consequences. No contradiction with annotations, but no meaningful behavioral transparency either.

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 short, but brevity here is under-specification rather than conciseness. The single sentence contains only command naming and boilerplate, none of which earns its place by helping an agent understand the tool. It is not egregiously long, but it is effectively content-free.

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

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

Despite having 9 parameters, required fields, enums, and an output schema, the description provides no conceptual or operational context. An agent cannot determine what 'add_file_output' does, what scene state it requires, what it returns, or what side effects may occur. The description is inadequate for even basic tool selection.

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

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

Schema description coverage is only 33%, meaning most parameters like name, format, baseName, outputDir, and colorDepth lack semantic context in the schema. The description adds zero parameter information and does not compensate for this gap, leaving an agent with five required parameters and no explanation of how they relate to the operation.

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 only restates the tool's name/title as a 'PartMe Blender Harness command' and adds generic risk/maturity boilerplate. It never states what the command actually does, such as adding a file output node to the compositor. This is essentially a tautology.

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?

There is no guidance on when to use this tool, what prerequisite state is required, or how it compares to sibling compositor tools like blender_compositor_configure or blender_compositor_create_strip_group. The 'Requirements' sentence refers only to generic session policy, not usage context.

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

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

Annotations are all false (readOnly, openWorld, idempotent, destructive), but the description adds no behavioral context. It mentions 'Risk: standard; maturity: L3' which are not behavioral traits. The description does not disclose side effects, required permissions, or any operational implications. It adds nothing beyond the annotations.

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

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

The description is very short, but this is under-specification rather than conciseness. It lacks any structural elements like a purpose statement or usage examples. The single sentence does not convey actionable information, so it is not a case of efficient brevity but rather a failure to specify.

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, no obvious output schema details in description) and the absence of any functional explanation, the description is completely inadequate. An agent cannot determine what 'add_tracking_mask' does, what inputs are needed beyond the schema, or what the expected result is. Even with an output schema present, the core action remains undefined.

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% (3 of 7 parameters have descriptions in the schema). The description does not mention any parameter, so it fails to compensate for the low coverage. Parameters like `clip`, `maskName`, and `_expectedSceneRevision` have no explanation anywhere, and the description provides no additional meaning.

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

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

The description does not state what the tool does. It only identifies it as a 'PartMe Blender Harness command' with the name `compositor.add_tracking_mask`, which is essentially restating the title. There is no verb, resource, or behavior described, making it a tautology and failing to distinguish it from any other Blender command.

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

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

No guidance is provided on when to use this tool or which alternatives might be more appropriate. The description mentions 'Per-request argument checks and session policy' but these are generic operational notes, not usage context. There is no mention of typical scenarios, prerequisites, or exclusion criteria.

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

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

Annotations only state negative facts (not read-only, not idempotent, not destructive, not open-world). The description adds 'Risk: standard; maturity: L3' and session-policy requirements, but it never discloses what changes the tool makes to the scene, what preconditions exist, or what effect the 'glare' and 'exposure' parameters have. No contradiction with annotations, but insufficient 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 short, but brevity is achieved by omitting functional content. Each clause is either a restatement of the title or generic policy/risk metadata. It reads like an internal registry entry rather than a tool explanation, so the sentences do not earn their 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 tool with six parameters, an output schema, and many compositor-related siblings, this description is operationally incomplete. It does not describe the operation, the effect on Blender's compositor, parameter semantics, or when to prefer it over sibling tools. An agent cannot reliably select or invoke this tool from the provided text.

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 50%, and the two domain parameters (glare, exposure) have no descriptions. The tool description adds no explanation of what these parameters control, what values are valid, or how they interact. An agent is left entirely to guess from names and types.

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 mostly restates the command name ('PartMe Blender Harness command `compositor.configure`') and only adds risk/maturity metadata. It does not say what configuring the compositor actually does, such as setting glare or exposure effects, so an agent cannot infer the tool's function from the description.

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

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

No guidance is given about when to use this tool versus alternatives like blender_compositor_add_file_output, blender_compositor_create_strip_group, or blender_compositor_inspect. The only usage-related sentence, 'Per-request argument checks and session policy still apply,' is generic policy rather than decision 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 provides no behavioral details beyond the annotations: it does not say what changes the operation makes, what scene state is affected, whether strip groups are organized into a node graph, or what the output represents. 'Risk: standard; maturity: L3' is process metadata, not behavioral transparency.

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 short, but brevity is under-specification rather than conciseness. The only substantive information is risk and maturity metadata, which repeats generic harness conventions and contributes no tool-specific 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 functional command with six parameters and a non-read-only annotation set, this description is almost entirely incomplete. Even though an output schema exists, the agent still has no idea what a strip group is, how creation fits into the compositor workflow, or what prerequisites apply.

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 leaves the key 'name' and 'exposure' parameters undocumented, and the description compensates with nothing. It provides no meaning for any of the six parameters, so an agent cannot infer what name refers to or what exposure controls.

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 only restates the command name and identifies it as a 'PartMe Blender Harness command'. It never states what the tool does, what a strip group is, or what effect creating one has. This is a tautology that cannot distinguish it from any other compositor command.

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?

There is no guidance on when to use this tool versus alternatives such as blender_compositor_add_file_output, blender_compositor_configure, or blender_compositor_inspect. The mention of 'per-request argument checks and session policy still apply' is generic boilerplate, not usage direction.

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 fully covered by structured data. The description adds 'Risk: read; maturity: L3' which provides some context about the operation's risk level and maturity classification. However, it doesn't disclose what the inspection actually does, what state it reads, or what the output contains. The description doesn't contradict the annotations, but it adds minimal behavioral context beyond 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 very short—two sentences—but the first sentence is largely redundant with the tool name and title. The second sentence about argument checks and session policy is generic harness boilerplate that doesn't add tool-specific value. It's concise but not informative; the brevity is achieved by omitting substance rather than by efficient writing.

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

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

Despite having an output schema and safe annotations, the description fails to explain what the compositor inspection returns or what aspect of the compositor it examines. The tool has zero required parameters and no description of what 'inspect' means in this context. An agent cannot predict what this tool does or what it will receive back. The output schema exists but the description should still orient the agent on what is being inspected and why they'd use 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?

Schema description coverage is 75% (3 of 4 parameters have descriptions), and the parameters are all harness infrastructure fields (_requestId, _authorization, _transactionId, _expectedSceneRevision) that are self-explanatory from their names and descriptions. The description adds no parameter-specific meaning, but the schema already documents these adequately. The _expectedSceneRevision parameter lacks a description, but its name is reasonably self-explanatory. Baseline 3 is appropriate since the schema carries the 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?

The description says 'PartMe Blender Harness command `compositor.inspect`' which is essentially a tautology—it restates the tool name and title without explaining what 'inspect' does, what resource it inspects, or what information it returns. The name suggests inspecting the Blender compositor, but the description never states the verb's object or the inspection's purpose, making it hard to distinguish from other inspect tools like blender_render_inspect or blender_sequence_inspect.

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 no guidance on when to use this tool versus alternatives. It mentions 'Per-request argument checks and session policy still apply' which is generic harness boilerplate, not usage guidance. With many sibling inspect tools (blender_scene_inspect, blender_rig_inspect, blender_tracking_inspect, etc.), an agent has no way to know when compositor.inspect is the right choice.

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 description is not required to repeat safety. It adds context about 'plugin-owned MCP adapter' and 'live guarded Harness session', which clarifies the exact scope of the check without contradicting annotations.

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

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

A single, compact sentence that front-loads the verb and resource. There is zero waste, and every word contributes to the meaning.

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

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

For a zero-parameter, read-only status check with a rich annotation profile and an output schema, the description fully specifies what the tool checks. Nothing an agent needs to call it correctly is missing; the scope and purpose are unambiguous.

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 are zero parameters, so the baseline is 4. The description adds no parameter-specific information, but none is needed; the schema is empty and coverage is 100%, making this a no-op dimension.

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 (check) and a specific resource (connection status of the plugin-owned MCP adapter to a live guarded Harness session). It distinguishes this tool from sibling status tools like blender_session_status by focusing on the connection/adapter reachability rather than session state.

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

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

The description implies usage as a diagnostic for connection reachability, but it does not explicitly mention when to choose this over alternatives such as blender_session_status or blender_production_status. No exclusions or conditions are provided, leaving the agent to infer the appropriate context.

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

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

The description adds only generic metadata ('Risk: standard; maturity: L3; Requirements...') rather than behavioral details about side effects, whether existing constraints are modified, or how the bone constraint is attached. Annotations already indicate this is not read-only or idempotent, so the description should supplement that but does not. No contradiction exists, but the behavioral burden is unmet.

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 text is short but under-specified; its sentences about risk, maturity, and request checks are generic and do not earn their place. There is no functional information that justifies the brevity. This is closer to a placeholder than a useful concise description.

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 16 parameters, required fields, and an output schema, this description is severely incomplete. It gives no indication of what the command accomplishes, which arguments are essential, what constraints can be added, or expected behavior. The agent cannot reliably select or invoke this tool based on the provided text.

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

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

The description mentions no parameters at all. With schema description coverage at only 38%, many important properties like bone, name, type, influence, subtarget, and targetObjectId remain unexplained in both the schema and description. The description does nothing to compensate for the low schema coverage.

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

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

The description only states 'PartMe Blender Harness command `constraint.add_bone`'—it restates the command name rather than explaining what the tool does. It provides no verb, resource, or outcome such as 'adds a constraint to the specified bone'. The name itself is suggestive, but the description does not clarify the operation or distinguish it from blender_constraint_add_object.

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?

There is no guidance on when to use this tool versus alternatives like blender_constraint_add_object or blender_constraint_keyframe_influence. The mention of 'Per-request argument checks and session policy still apply' is generic operational boilerplate, not usage direction. The description offers no context, prerequisites, or exclusions.

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

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

Annotations are all false and provide no safety hints. The description only mentions 'Risk: standard' and 'maturity: L3', which are operational metadata, not behavioral traits. It does not disclose side effects, prerequisites, or any post-conditions.

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 extremely short, which is under-specification rather than conciseness. While it is structured with risk and maturity labels, it provides no functional information, so it fails to earn its place as a useful description.

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 10 parameters, nested objects, and an output schema, this description is grossly incomplete. An agent cannot determine what the tool does, what inputs are needed, or what the output represents. It lacks any meaningful context for 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 only 40%, with only 'target' having a description. The tool description does not explain any of the 10 parameters, including required ones like 'bone', 'owner', or 'type'. It fails to compensate for the schema's gaps.

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

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

The description only restates the command name 'constraint.add_object' and provides risk/maturity metadata. It does not state what the tool does, such as adding an object constraint to a bone or object. This is a tautology, offering no functional clarity.

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

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

No guidance is given on when to use this tool versus alternatives like blender_constraint_add_bone. The description mentions generic requirements but no context for selecting this tool over its 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 all hints false, indicating a write operation that is not destructive or idempotent, but the description adds no behavioral context. It does not mention whether setting influence is reversible, whether it requires specific permissions, or what side effects occur. The 'Risk: standard' line is about reliability, not behavior, so the description contributes nothing beyond the minimal 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?

The description is short, but this is under-specification rather than conciseness. It front-loads no useful information and every sentence is generic metadata. A single sentence naming the command and risk level does not earn its place because it doesn't help the agent decide or invoke the tool.

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

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

Despite having an output schema and nested objects, the description is completely inadequate for a tool with 8 parameters and 5 required ones. It lacks a statement of purpose, usage context, parameter explanations, or behavioral notes. An agent cannot safely call this tool based on the current description.

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

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

With schema description coverage at 38%, the description must compensate by explaining the key parameters (constraintName, frame, influence, owner, etc.), but it says nothing about them. The agent must rely entirely on the schema, which lacks descriptions for most properties. The description adds zero value to parameter understanding.

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

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

The description only repeats the command name 'constraint.keyframe_influence' and adds risk/maturity metadata, but never states what the tool actually does. There is no verb, no resource, and no effect described, so an agent cannot infer that it sets keyframe influence values for a constraint. It is essentially a tautology with added metadata, similar to the 'Process' example.

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 no guidance on when to use this tool versus alternatives. It mentions 'Per-request argument checks and session policy still apply,' which is about authentication, not usage context. No exclusions or alternative tool names are given, leaving the agent to guess whether this is the right command for keyframing constraint influence.

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?

All annotations are false, so the description carries the full disclosure burden, but it only offers generic metadata: 'Risk: standard; maturity: L3'. It does not say what a configure operation changes in the scene, whether it mutates the target curve, whether existing settings are replaced, or what side effects occur. This is minimal operational labeling, not behavioral transparency.

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 short, but neither sentence earns its place: the first is a tautological restatement and the second is generic harness boilerplate that could apply to any tool. This is under-specification, not disciplined conciseness — brevity that buys nothing.

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

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

This is a 9-parameter mutation tool with non-committal annotations, low schema coverage, and numerous curve-related siblings that require differentiation. The description leaves purpose, parameter semantics, usage context, and behavioral effects entirely unspecified. The existence of an output schema does not compensate for the absence of any orienting information.

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

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

Schema description coverage is only 33%, leaving six functional parameters (name, objectId, bevelDepth, resolution, bevelResolution, _expectedSceneRevision) undocumented in the schema. The description text compensates for none of this — it never references a single parameter or explains what these values control. An agent cannot determine units, semantics, or valid usage for the core curve settings.

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 restates the tool's identity — 'PartMe Blender Harness command `curve.configure`' — without stating what the tool actually does. There is no verb+resource statement, no mention that it configures curve properties such as bevel or resolution, and no behavioral claim. This is effectively a tautology of the title, and the functional purpose is entirely missing.

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

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

No guidance is given on when to use this tool versus curve-related siblings such as blender_curve_create, blender_object_create_curve, or blender_curve_to_mesh. The 'Requirements: Per-request argument checks and session policy still apply' sentence is operational boilerplate about invocation constraints, not direction on selecting this tool over alternatives.

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

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

The annotations already signal this is not read-only, not idempotent, and not destructive. The description adds operational context like 'Risk: standard; maturity: L3' and 'Per-request argument checks and session policy still apply', which is slightly useful, but it does not disclose what happens to the scene or objects, what dependencies exist, or what the side effects of creating a curve are.

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 short, but shortness is not conciseness when the sentences only restate the command and generic runtime policy. The first sentence is redundant with the command name, and the second is boilerplate. It is under-specified rather than efficiently informative.

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

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

Despite having 12 parameters, an output schema, and a large sibling list, the description provides almost no actionable context. It does not state the tool's purpose, behavior, preconditions, side effects, or relationship to similar curve and object tools. An agent cannot confidently invoke or validate this tool based on the definition.

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 needed to compensate by explaining key parameters such as name, points, splineType, handleType, and bevelDepth. It does not mention a single parameter or provide any guidance on how to construct valid arguments. The sparse schema-level descriptions are insufficient, and the description adds no semantic value.

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

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

The description simply restates the command name as 'PartMe Blender Harness command `curve.create`' without stating what the tool does. It is a tautology: no verb, resource, or effect is described. An agent cannot tell from the description that this creates a curve, especially with siblings like blender_object_create_curve and blender_curve_configure nearby.

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?

There is no guidance on when to use this tool versus alternatives such as blender_object_create_curve or blender_curve_configure. The description only mentions generic risk and policy requirements, which do not help an agent choose or sequence this tool 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 are all false, providing no safety profile, and the description adds no behavioral context. It mentions 'Risk: standard' and 'maturity: L3' but these are metadata, not behavior. There is no disclosure of side effects, mutation, or scene changes. For a likely mutating operation (curve to mesh), this is a critical 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 extremely short (one sentence), which could be seen as concise, but it is under-specified rather than efficiently informative. There is no wasted text, but the content fails to convey essential purpose or usage. It is more of a placeholder than a concise summary.

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 6 parameters, an output schema, and a likely complex operation (converting curves to meshes), the description is completely inadequate. It provides no context on inputs, expected output, or behavior, and does not compensate for the missing schema descriptions on key parameters.

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

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

The description provides no explanation of any parameters. The schema has descriptions only for harness plumbing parameters (_requestId, _authorization, _transactionId), while the tool-specific parameters (name, objectId, _expectedSceneRevision) have no descriptions. The description adds no meaning to any parameter.

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

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

The description is essentially a tautology: it states 'PartMe Blender Harness command `curve.to_mesh`' without explaining what the command does. It does not use a verb+resource format, and it fails to distinguish the tool from siblings like blender_curve_create or blender_mesh_edit. An agent cannot infer the operation from the description alone.

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?

There is no guidance on when to use this tool versus alternatives, no context for selection, and no exclusions or prerequisites mentioned beyond generic 'session policy' which applies to all tools. The description does not reference sibling tools or conditions for use.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds genuinely new behavioral context: the request is gated and requires local user approval, a client cannot approve its own request, and the same request id is retried after approval. This goes beyond what the annotations convey and clarifies an unusual async approval interaction.

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 text is short and front-loaded with the command name, but it is dense with internal jargon ('gated', 'maturity: L3', 'replay safety', 'milestone transaction id') that is not explained. No sentences are wasted, but the ones present lean on unexplained terminology rather than clear exposition.

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

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

Despite an output schema being present, the description is incomplete for an export tool with 6 parameters, a nested object, a destructive annotation, and a direct sibling (blender_export_file). It omits what is exported, how the extended variant differs, and any parameter semantics, leaving an agent under-equipped to invoke it correctly.

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

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

With only 50% schema description coverage and 6 parameters (including a nested path object and three underscore-prefixed harness params), the description adds nothing about parameter meaning. It does not clarify format, path, or the transaction id semantics beyond what the schema already states, and it fails to compensate for the 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 'PartMe Blender Harness command export.extended' which largely restates the tool name rather than stating what it does. It never says what gets exported (scene? objects? to what format?) or how this 'extended' variant differs from the sibling blender_export_file. An agent cannot tell what resource and verb this covers from the text.

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

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

The description explains the gated approval flow (local user approval, no self-approval, retry semantics) but gives zero guidance on when to choose this tool over blender_export_file or any alternative. No exclusions, no conditions, no comparison. The approval context is operationally useful but does not cover selection 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?

Beyond the annotations (destructive, non-idempotent), the description discloses the gated risk, the local-user approval requirement, the prohibition on self-approval, the retry-with-same-request-id flow, and the committed-snapshot prerequisite. This is rich behavioral context that materially changes how an agent should handle the tool.

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

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

The description is compact and front-loaded, stating the command and risk level first, then packing approval behavior and prerequisites into two efficient sentences. There is no filler; every clause contributes operational information an agent needs.

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?

It covers approval and prerequisite context well, and the output schema plus annotations help cover return-value and safety concerns. However, the export parameters are extension-dependent and the schema lacks descriptions for path and most options, leaving the agent without enough detail to reliably construct valid parameters.

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

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

The description adds meaning to some parameters: path must be an approved output root, snapshotId must reference a committed snapshot, and _requestId is reused after user approval. However, schema description coverage is only 44%, and many parameters such as overwrite, frameStart, frameEnd, and _transactionId remain unexplained in both the schema and description, so it only partially compensates for the 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 states the command as 'export.file', which conveys a specific verb (export) and resource (file), and the harness context clarifies it is the Blender file-export operation. It does not explicitly differentiate it from the sibling blender_export_extended, so it falls short of a 5.

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 states key invocation conditions: local user approval is required, the same request id must be retried after approval, an approved output root is required, and a committed snapshot must exist. It does not compare against alternatives like blender_export_extended or state when this tool should be avoided, so usage guidance is contextual but not fully directional.

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

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

Annotations already indicate this is a non-read-only, non-idempotent operation. The description adds only generic 'Risk: standard; maturity: L3' and a session-policy note, but does not disclose what side effects adding a node has on the scene, whether a geometry node group must already exist, or how the node is integrated. It provides minimal value beyond the annotations.

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

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

The description is short, but this is under-specification rather than effective conciseness. It contains only a command identifier and generic risk/maturity labels, and every useful explanatory sentence is missing.

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 mutating tool with no readOnly/idempotent hints and only 38% schema coverage, the description should explain what the node addition does, what parameters like nodeType and groupName mean, and how this relates to the geometry node workflow. The presence of an output schema does not compensate for the complete absence of functional 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 only 38%, and the meaningful parameters (groupName, name, nodeType, label, _expectedSceneRevision) have no descriptions in the schema. The tool description does not compensate by explaining any of these parameters, their formats, or their roles, leaving the agent without essential semantics for calling the tool.

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

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

The description identifies the command name and harness context but never states what the tool actually does beyond 'add_node'. It does not say it adds a node to a Blender geometry node group, making it essentially a restatement of the name/title with no functional explanation.

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?

There is no guidance about when to use this tool versus the many related geometry node tools such as blender_geometry_nodes_create_group, blender_geometry_nodes_connect, or blender_geometry_nodes_set_node_input. The only extra sentence concerns risk and session policy, which does not help an agent select this tool over alternatives.

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