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

No annotations are provided, so the description carries the full behavioral burden. The authoring actions imply mutation, but the description does not disclose side effects, whether changes are reversible, permission requirements, or what compile or connect_pins actually do. The action names give minimal implicit context but fall well short of transparency for a mutation-heavy 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 a single, front-loaded sentence with no wasted text. Its brevity is efficient, though it borders on under-specification rather than pure 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 multi-action tool with a nested params object, no output schema, no annotations, and 0% schema description coverage, the description is too thin. It enumerates action names but leaves the per-action parameter contract and behavioral expectations almost entirely unaddressed.

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

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

Schema description coverage is 0% and there are two parameters, one of which is a nested object. The description usefully enumerates valid values for the action parameter, but it says nothing about the structure or requirements of the params object for each action, leaving half the parameter semantics undocumented.

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 resource clearly as Blueprint authoring and enumerates the specific actions it supports (create, add_variable, add_function, etc.). That makes it distinguishable from siblings such as ue_world or ue_material, though the individual action names are not explained.

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 no guidance on when to choose this tool over alternatives, no prerequisites for authoring operations, and no exclusions. It only lists action names, leaving the agent to infer usage context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden and provides none of it. It does not disclose that the create_* and set_* actions mutate project assets, whether those writes are destructive or reversible, what permissions are needed, or what a call returns.

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

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

A single terse line, front-loaded with the resource and then the operations, with no filler sentences. It is efficient, though the brevity reflects under-specification rather than disciplined concision.

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

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

For a two-parameter dispatcher with a free-form nested params object, no annotations, and no output schema, the description is far too thin. An agent knows the action names but not what shape params must take for any of them, which is the minimum needed 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?

Schema coverage is 0% and the 'action' string has no enum, so the enumerated action names are genuinely useful parameter information that the schema does not provide. However, the nested 'params' object — which must carry different arguments per action — is completely unexplained, leaving the harder half of the call undocumented.

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 resource ('Materials and instances') and enumerates six concrete operations, so an agent can tell this is the material authoring/querying surface rather than ue_world, ue_blueprint or ue_media. It lacks a single unifying verb ('manage'/'author'), but the action list makes the domain unambiguous.

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

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

There is no guidance on when to use this tool versus siblings, nor when to prefer create_material over create_instance, nor any prerequisites (e.g. asset must exist before set_parameter). The action list implies what is possible but says nothing about selection criteria or ordering constraints.

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

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

No annotations are provided, so the description carries the full burden. It reveals only that actions like import_sound and spawn_niagara exist, implying mutation, but says nothing about side effects on assets or levels, permissions, reversibility, or the dispatch semantics of the action/params/timeout trio.

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 a single compact line with the domain grouping front-loaded, so there is no padding. However, the compression goes too far: the slash-separated token list reads as under-specification rather than tight, purposeful prose.

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

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

With no annotations, no output schema, 0% parameter documentation, and a free-form nested `params` object, this description is far short of what an agent needs to invoke the tool reliably. Missing are the action-to-parameter mapping, return behavior, and any failure/timeout 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 0% for three parameters, including a nested, untyped `params` object. The description implicitly enumerates valid `action` values but does not state which params each action accepts, what `timeout` governs, or how `params` is shaped — a significant compensation gap for the most important schema field.

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

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

The description names three domains (Audio, Niagara, Sequencer) and enumerates six concrete action strings, which lets an agent infer this is a media/asset operation dispatcher for Unreal Engine. However, it never states the tool's purpose in a verb+resource form, and the domain labels are only implicit differentiation from siblings like ue_material or ue_blueprint.

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 / when-not-to-use guidance and no mention of the sibling tools (ue_world, ue_blueprint, ue_material, etc.) that an agent must choose between. The listed actions imply scope, but nothing routes the agent away from the wrong 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?

With no annotations, the description carries the full burden, and it does disclose real behavior: partial results survive a failing step and an unresponsive editor aborts rather than silently dropping remaining steps. However, it never says whether steps after a failure still execute, how errors surface, or what the per-step timeout means, which are exactly the ambiguities that matter for a batch executor.

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

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

One front-loaded sentence that leads with the action and then the reporting behavior. No filler, though the partial-reporting clause is packed tightly enough that its meaning is slightly murky.

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

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

No output schema and no annotations for a tool whose whole value is reporting per-step outcomes, yet the description never says what comes back on partial success. Combined with zero parameter documentation and a 64-step cap disclosed only in the schema, an agent cannot reliably call or interpret this tool from the description 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?

Schema description coverage is 0% and the single parameter is a nested array of step objects (domain, action, params, timeout, maxItems 64). The description adds nothing about these: no ordering semantics, no explanation of how per-step params pass through, no timeout units or per-step vs global scope.

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?

"Run ordered steps in one call" states a batching verb and hints at multi-step orchestration, but never says what a step is or that it dispatches into the domain siblings (world/blueprint/material/...). The agent must read the nested enum to infer that this is a fan-out across domains rather than a distinct capability.

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 batch via ue_pipeline versus calling ue_world, ue_blueprint, ue_material, ue_media or ue_vision directly. Ordering is mentioned but not as a selection criterion, so the agent gets an implied usage rather than explicit routing.

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

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

With no annotations, the description must carry behavioral disclosure; it says the result includes whether the editor answers, which signals a live health probe, and lists resolved class table and pipeline step limit. It does not explicitly state read-only/side-effect behavior or auth/rate limits, leaving important behavioral context implicit.

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

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

One front-loaded sentence with a colon-separated list and no filler. Every phrase describes a returned fact.

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

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

With no output schema, the description does explain the main return values (endpoint, editor availability, class table, pipeline step limit). For a zero-parameter status tool this is reasonably complete, though it could say what format these facts take or how to interpret failures.

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 and schema coverage is 100%, so the baseline is 4. The description does not need to explain 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 names the concrete facts returned—endpoint, editor responsiveness, class table, and pipeline step limit—so an agent knows this is a bridge/editor status probe. It lacks an explicit verb and does not differentiate from siblings such as ue_pipeline, so it is clear but not maximally sharp.

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 explicit when-to-use or when-not-to-use statement, nor any reference to alternatives. The content implies a health/status check, but the agent must infer that from the listed facts.

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

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

No annotations exist, so the description carries the full disclosure burden. It does hint that frame mutates editor camera state while capture produces an image, but it never states how the image is returned (inline, file path, handle), whether framing requires the actor to be selected/visible, or what permissions/mode (PIE vs editor) are needed.

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 front-loaded sentence with no filler; the two modes are presented compactly. It is arguably too terse given the undocumented payload, but there is no wasted text.

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 a nested free-form params object at 0% coverage, no annotations, and no output schema, the description should explain how to shape the action/params payload and what capture returns. Neither is covered, so an agent cannot reliably invoke this tool from the definition 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?

Schema description coverage is 0% and the only structured info is a required untyped 'action' string plus an opaque nested 'params' object. The description implies the action values ('capture', 'frame') and that frame needs an actor reference, but it names no parameter keys or nested shape, leaving the payload essentially undocumented.

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?

Names the resource (the editor viewport) and enumerates the two concrete actions: capture the active viewport as an image and frame the camera onto an actor. The 'viewport eyes' metaphor is decorative but the parentheticals make the capability unambiguous and distinct from the world/blueprint/material 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?

Lists what the two modes do but gives no condition for choosing between them and no exclusions relative to siblings (e.g., when to use ue_world for actor inspection instead of framing on an actor here). An agent must guess which action applies to its situation.

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

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

With no annotations, the description carries the full burden; it does add real value by disclosing that spawn validates friendly class names and refuses unresolvable ones, and that set_transform reads back the landed transform. However, it is silent on the destructive nature of delete, on any permissions or editor-connection requirements, and on level_streaming side effects.

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

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

Purpose is front-loaded, followed by the action enumeration and then two behavioral caveats; there is no filler. The long slash-delimited action run-on is dense but functional rather than wasteful.

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

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

A single dispatcher covering ~16 actions with 7 parameters, a nested params object, no annotations, and no output schema needs a per-action parameter contract that this description does not provide. An agent can identify the tool but cannot reliably determine which parameters each action requires or what state it mutates.

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

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

Schema description coverage is 0%, so the description must compensate and largely does not: the 'params' object is never mentioned, and the mapping of location/rotation/scale to specific actions is only hinted via set_transform. The note about actor_class resolving to /Script/Engine.* is the one genuine semantic addition.

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?

Names the resource precisely ('scene actors on the editor side') and enumerates the specific operations it dispatches (spawn, duplicate, attach, set_lighting, level_streaming, etc.), so an agent knows this is the actor/level-manipulation entry point. It does not explicitly contrast itself with siblings like ue_blueprint or ue_material, but the actor-scoped framing does most of the disambiguation work.

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 action list implies when to reach for this tool, but there is no explicit 'use this when / use X instead' guidance and no routing to ue_blueprint, ue_material, or ue_status. An agent must infer from the action vocabulary which requests belong here versus a sibling tool.

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