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

The description only says 'bind' and 'attachment,' which implies a mutating operation, but there are no annotations (none provided) and no behavioral details: what happens to existing bindings, whether it overwrites or appends, permissions needed, or any operation details. With the burden fully on the description, this gap is significant.

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

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

A single sentence: 'Bind an actor to a sequence for animation attachment.' It is concise and front-loaded. Every word of the description is useful.

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 simple two parameter tool with 100% schema coverage. However, there is no output schema and no behavioral details or effects on the asset/sequence/relationship are described. The description does not clarify return values, nor the possible side effects or postconditions.

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 parameter schema covers both 'actor_name' and 'sequence_path' with descriptions, so the structured parameter help is already complete. The description text adds a bit of semantic nuance not strictly in the schema ('label' vs 'name') but largely overlaps. Since 100% of the parameters are described in the schema, the baseline is a 3.

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

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

The description clearly states the verb and resource: 'Bind an actor to a sequence for animation attachment.' It identifies the specific operation (binding actor to sequence) but does not explicitly differentiate it from sibling tools like add_track or set_actor_tags. It conveys a unique function but lacks explicit separation from alternatives.

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 versus alternatives or when not to use it. The implied context is 'for animation attachment', but there are no explicit exclusionary criteria, prerequisites, or recommended usage situations.

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 provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects (e.g., modification of the blueprint asset), persistence, or error conditions. This is a significant 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 a single sentence with no filler, front-loading the action and target. Maximum conciseness without sacrificing clarity.

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

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

The tool has 3 parameters, no output schema, and no annotations. The description is too brief to cover prerequisites, behavior on failure, or relation to the blueprint asset (e.g., whether it saves or requires an open blueprint). It only communicates the core purpose.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter information beyond what the schema's property descriptions provide, but no deduction is needed since the schema is complete.

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

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

The description states a specific action ('Add a component') on a specific resource ('a Blueprint'), which clearly distinguishes from sibling tools like add_blueprint_variable and add_blueprint_function. The verb and object are 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?

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or exclusions. The tool name and description imply its use, but there is no explicit context or comparison to sibling tools.

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

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

There are no annotations, so the description must disclose behavioral traits. It only states the action without mentioning side effects like asset modification, whether compilation is triggered, or whether changes are reversible. For a mutation tool, this lack of transparency is a significant 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 a single, clear sentence with no wasted words. It is appropriately concise for a tool with only two parameters, though it sacrifices details that could improve usefulness.

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?

Without annotations or an output schema, the description fails to provide critical context for a mutation tool, such as preconditions, side effects, or post-conditions. This makes the tool risky to invoke without additional 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?

The schema provides 100% coverage with descriptions for both parameters ('Function name' and 'Blueprint asset path'). The tool description adds no additional meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description 'Add a custom function to a Blueprint' clearly states the action (add) and the resource (custom function to a Blueprint). It effectively distinguishes this tool from siblings like add_blueprint_component and add_blueprint_variable, which add other element types.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any prerequisites or exclusions. The usage is only implied by the tool name and bare description, which is insufficient for an agent to decide between this and similar 'add' 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?

The description does not disclose any behavioral traits beyond the basic action. It fails to mention side effects such as whether the Blueprint asset is modified on disk, whether compilation is triggered, or what happens if the variable already exists. Since no annotations are provided, the description carries the full burden, and this is insufficient.

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 unnecessary words. It is concise and well-structured, though it is quite terse and could provide a bit more detail without becoming verbose. This is efficient but border-line under-specification.

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 absence of annotations and output schema, the description is too brief to be complete. It does not explain side effects, prerequisites, or the significance of the default_value parameter. For a mutation tool that modifies a Blueprint asset, more context is needed for an agent 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?

The input schema has 100% description coverage for all 4 parameters, so the schema already explains variable_name, variable_type, blueprint_path, and default_value. The tool description adds no additional parameter semantics. According to the rubric, high schema coverage yields a baseline of 3.

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

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

The description clearly states the action: 'Add a variable to a Blueprint.' It uses a specific verb ('Add') and a specific resource (a variable), which distinguishes it from sibling tools like add_blueprint_component and add_blueprint_function. The purpose is unambiguous even though minimal.

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 does not mention any prerequisites, exclusions, or contrast with sibling tools (e.g., add_blueprint_function). The only implied usage is the obvious action, but there is no explicit context or alternative differentiation.

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 burden of disclosing behavior. It reveals a meaningful dependency: 'Requires the optional C++ plugin for full node type support. Falls back to Python for basic operations.' This explains potential degradation in functionality. However, it does not disclose side effects, return values, or failure modes, which are important for a mutation 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 two sentences and immediately states the core action with a noun phrase. Every word contributes: the first sentence defines the purpose, the second provides essential caveats. No filler or redundancy.

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

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

The tool mutates a Blueprint graph and has no output schema or annotations. The description does not mention what the tool returns, whether the blueprint must be loaded/compiled, or what happens if the event graph is missing. While the plugin caveat and schema cover some aspects, important operational details are absent for a mutation tool of moderate complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds minimal parameter-related value beyond noting that node type support may be limited without the plugin, which relates to the node_type parameter. It does not clarify coordinate ranges, property formats, or blueprint path expectations beyond the schema's own descriptions.

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

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

The description opens with a specific verb and resource: 'Add a node to a Blueprint's event graph.' This clearly distinguishes it from sibling tools like add_blueprint_component and add_blueprint_variable, which target different Blueprint elements. The scope is unambiguous.

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

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

The description gives context about the optional C++ plugin requirement and Python fallback, which implies when the tool may be limited. However, it does not explicitly state when to use this tool over alternatives like connect_graph_nodes, nor does it mention exclusions such as Blueprint types or unsupported node categories. Usage guidance is present but implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic mutation action ('Add') without explaining side effects, whether duplicate tracks are allowed, what happens if the binding does not exist, or what the tool returns. This is a significant transparency gap for a mutating operation.

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 clear sentence with no filler. It is front-loaded with the action and target, and every word contributes 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?

With no annotations and no output schema, the description must do more than one sentence. It does not explain workflow context (e.g., create sequence → add actor binding → add track), behavioral caveats, or expected outcomes. Even though the schema documents parameters well, the overall tool context is under-specified for an agent.

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

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

Schema description coverage is 100%, and each parameter already has a clear description (e.g., binding_id comes from add_actor_binding or get_sequence_info). The tool description adds no parameter-level meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Add a track to an actor binding in a sequence.' It clearly distinguishes this tool from siblings like add_actor_binding, which adds a binding itself, and create_level_sequence, which creates a sequence. The intended operation is immediately understandable.

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

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

The phrase 'to an actor binding in a sequence' implies the user must already have a sequence and a binding, but there is no explicit guidance on when to use this tool versus alternatives, no prerequisites stated, and no caveats about ordering (e.g., after add_actor_binding). Usage is implied rather than spelled out.

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 the burden of explaining side effects and constraints. It only says 'Apply', which implies a modification, but does not disclose whether the original asset is mutated, what the modifier does, or any potential side effects. This is insufficient given the absence of annotations.

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

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

The description is a single sentence, highly concise with no fluff. It covers the essential action and object, though it lacks elaboration. Structure is simple and direct.

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?

Without annotations alert, the description must carry full weight. It does not explain what happens when applied, whether it alters the original sequence or creates a new one, any prerequisites (e.g., sequence must exist), or return values. Given two parameters and no output schema, the description is too thin for reliable tool selection and invocation.

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

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

Schema descriptions are present for both parameters ('AnimSequence path' and 'Animation modifier class name'), achieving 100% coverage. However, they are terse and do not explain expected formats, allowed values, or how they interact. Baseline 3 is appropriate since schema provides basic definitions but no additional semantics.

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

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

The description clearly states the action (apply) and the resource (animation modifier to an animation sequence). It is specific enough to distinguish from generic tools like 'apply_material', though it does not explicitly differentiate from sibling animation tools or list alternatives. The verb-resource pairing is clear, but lacks detail on what 'modifier' means in this context.

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

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

No guidance is provided on when to use this tool versus similar animation tools (e.g., create_anim_blueprint, get_sequence_info). The description is minimal and does not mention exclusions, prerequisites, or scenarios where this tool is preferred over others.

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 full responsibility for behavioral disclosure. It only mentions the action without noting side effects, error conditions, or whether the operation is destructive or reversible.

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 concise sentence with no redundancy, making it appropriately sized for the operation's simplicity.

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 minimal and lacks crucial context such as error handling, expected outcomes, or edge cases, despite the tool's moderate complexity. It is not complete enough for a user to fully understand the behavior.

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

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

The tool description adds no extra meaning beyond the schema's parameter descriptions, which are already trivial ('Actor name or label', etc.). It does not clarify how parameters relate to the operation or provide default behaviors.

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

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

The description clearly states the verb 'apply' and the resource 'material', targeting 'an actor's mesh component', which is specific and distinguishes from other tools like execution or testing.

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 information is provided about when to use this tool versus alternatives, nor are any prerequisites or context given. The description lacks any guidance on selection.

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

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

With no annotations, the description carries the burden. It discloses that the tool executes a multi-stage pipeline and can optionally deploy/run, which is useful. However, it does not mention side effects, prerequisites, or output behavior; for a complex build pipeline this is limited 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?

Description is a single, front-loaded sentence that efficiently communicates the tool's purpose and pipeline steps. No unnecessary words or repetition of schema details.

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

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

For a 12-parameter pipeline with no output schema and no annotations, the description is somewhat minimal. It conveys the high-level purpose but omits details like what the command returns, how long it takes, or how it relates to sibling single-step commands. Still, the schema covers parameter semantics, so it is not wholly inadequate.

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

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

Schema description coverage is 100% for all 12 parameters, each with its own description. The tool description does not add parameter-level semantics beyond this, 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?

Description clearly identifies the tool as the full BuildCookRun pipeline, enumerating the stages (build, cook, stage, package, optionally deploy/run) and positioning it as the primary packaging command. This is specific and distinguishes it from single-step siblings like build_target or cook_content.

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 says this is the primary command for packaging, which gives some context, but it does not explicitly mention alternatives or explain when to use specific tools like cook_content or package_project. The 'primary' phrasing implies preference but lacks explicit when/when-not guidance.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It does not state whether this operation is read-only or destructive, what side effects it may have (e.g., modifying build artifacts), or whether it requires special privileges. For a tool that executes scripts, this lack of transparency is a significant 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 a single concise sentence that is front-loaded with the core action. It is efficient and to the point, but it could add a bit more context without becoming verbose, such as a note about the `additional_args` parameter or typical usage patterns.

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 (execution of scripts, potential side effects, and need for clear behavioral expectations) and the absence of annotations or an output schema, the description is underspecified. It does not explain return values, error handling, or the effect of the `additional_args` parameter, leaving the agent with an incomplete picture for a potentially impactful operation.

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 'BuildGraph XML script' and 'target', which aligns with the script_path and target parameters, but it adds no additional semantics beyond the schema. The schema already describes each parameter at 100% coverage, so the description does not substantially enhance understanding of parameter usage or formats.

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 it executes a BuildGraph XML script for CI/CD automation, specifying the resource (XML script) and the action (execute). It is somewhat distinct from siblings like build_target or build_cook_run, but it doesn't explicitly differentiate itself or clarify what BuildGraph is, so it falls short of a perfect 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?

The description implies it is used for CI/CD automation, but it does not provide explicit guidance on when to use this tool versus alternatives like build_target or build_cook_run. No exclusions or alternative tool mentions are made, leaving the usage context somewhat ambiguous.

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, placing full burden on the description. The single sentence 'Build a plugin standalone' discloses no behavioral traits such as side effects, required environment, outputs, or error handling. This is a significant 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 brief, but this is under-specification rather than concise clarity. It lacks essential context that a tool description should provide, making the brevity a detriment rather than a strength.

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 build operation with no annotations and no output schema, the description should explain what 'standalone' means, the build process, expected outputs, and potential prerequisites. It provides none of this, leaving the agent without adequate context for effective use.

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

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

Schema description coverage is 100%, so the baseline is 3. All three parameters are documented in the schema, and the description does not add any additional semantic meaning beyond what the schema already provides.

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

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

The description uses a specific verb ('Build') and resource ('plugin'), which clearly indicates the tool's core function. It partially distinguishes from sibling build tools by targeting plugins, though the term 'standalone' is vague and could be more explicit about the build output type.

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 instead of alternatives. Sibling tools like build_target, build_cook_run, and package_project exist, but the description does not mention any differentiation or context for choosing 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It does not mention that building modifies the project, may be long-running, requires credentials or environment setup, or whether it cleans before building. The brief statement 'Compiles the project's C++ code' is tautological and adds no transparency beyond the name.

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 only two short sentences, so it is concise. However, it is so minimal that it misses important structural information like expected inputs, outputs, or side effects. While it is not verbose, it is under-specified and could benefit from more specific detail without being overly long.

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?

Building a C++ target is a complex operation that typically involves compilation, possibly linking, and can affect the project state. The description does not mention that it compiles for a specific platform or configuration, what happens on success/failure, or whether it returns a build status. Without an output schema, the description should explain what the tool returns, but it doesn't. This is incomplete for a build operation.

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?

All four parameters have descriptions in the schema (coverage 100%), so the schema already explains their meanings. The tool description adds no parameter-level detail beyond what the schema provides, which is consistent with baseline 3. The schema's descriptions are adequate (e.g., 'Build target: Editor, Game, Client, Server').

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

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

The description clearly states the action: 'Build a C++ target using UnrealBuildTool' and adds 'Compiles the project's C++ code.' This is a specific verb-resource pair that distinguishes it from sibling tools like build_plugin, build_cook_run, or generate_project_files, which have different scopes.

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 such as build_plugin, cook_content, or package_project. There is no mention of prerequisites, exclusions, or scenarios where a different tool would be more appropriate. The description merely states what it does without contextual 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?

No annotations are present to disclose read-only status, destructive potential, or rate limits. The description's verb 'call' implies invocation, but no side effects, permissions, or error behavior are disclosed.

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

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

The description is one concise sentence of nine words. It omits examples, parameter details, and usage context, making it too terse to compensate for the sparse annotations and ambiguous preset terminology.

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

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

There is no output schema, no behavior on failure, no return value description. The preset concept is undefined, and given the parametrized params object and semantic gap, the agent cannot reliably know what the function returns, whether it is safe, or if it accepts nonstring values. Lacks key information for a call-related tool.

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

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

The input schema covers 100% of parameters with names and types (including an 'other properties' object for flexible parameters). However, the description only restates the schema label ('Function parameters') and adds no deeper meaning about specific expected keys, value formats, or the parameter object's structure.

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

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

The description states a specific action: 'Call a function' exposed via a Remote Control preset, but it does not identify what a Remote Control preset is, how functions are exposed, or what makes this distinct from sibling tools like get_preset_info, list_presets, or get_preset_property.

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 such as execute_python_code, execute_console_command, or direct preset property getters. There is no mention of context, preconditions, or consequences.

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 of revealing side effects. 'Clean build artifacts' implies deletion or removal, but it does not state what exactly is deleted, whether it is safe to run, or if it has any irreversible consequences. This is a significant gap for a potentially destructive operation.

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

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

The description is a single sentence with no fluff, which is concise. It is front-loaded with the primary action. However, it lacks any elaboration on scope or effects, which might make it too terse for a destructive operation.

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 lack of annotations and output schema, the description must convey the full behavior. It only states 'clean build artifacts' without detailing what is removed, whether it is irreversible, whether it affects the entire project or just the specified platform, or what the outcome is. The tool is likely destructive (cleaning) but no warnings or side effects are mentioned. Hence, incomplete for safe usage.

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

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

Schema description coverage is 100%: the only parameter 'platform' has a description 'Target platform' in the schema itself. The tool description adds no further meaning about the parameter, so it provides minimal added value. Baseline of 3 is appropriate since the schema already covers the parameter.

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

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

The description clearly indicates the tool's purpose: to clean build artifacts from the project. The verb 'clean' and resource 'build artifacts' are specific, and it distinguishes from sibling build tools (e.g., build_target, package_project) which create artifacts. However, it does not specify what specific artifact types are cleaned (e.g., intermediate files, caches), leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, typical scenarios, or cases where this should not be used (e.g., avoid during active builds). With many sibling tools for building and cooking, the description lacks direction for an agent to decide when this is the appropriate 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely states 'Compile a Blueprint' without revealing side effects, whether it saves/overwrites, what happens on compilation errors, or any required setup. This is too vague to inform an agent about potential impacts or prerequisites.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is efficiently minimal, though perhaps overly terse. It earns its place but leaves significant information unsaid, preventing a perfect 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?

For a compilation tool with no output schema, no annotations, and only one self-explanatory parameter, the description is insufficient. It does not mention expected outcomes, compilation errors, or whether the compiled asset is saved/updated, leaving the agent without critical context for such an operation.

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

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

The input schema already fully covers the single parameter 'blueprint_path' with a clear description ('Blueprint asset path'). The tool description adds no additional semantic detail about the parameter, but since schema coverage is 100%, the baseline of 3 applies.

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

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

The description states a specific verb ('Compile') and resource ('Blueprint'), making the basic action clear. However, it lacks detail on what compiling entails and does not differentiate from related sibling tools like create_blueprint or get_blueprint_info beyond the verb itself. It is a minimal, generic statement rather than a fully clarifying one.

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 build_target, create_blueprint, or recompile_material. No prerequisites, expected usage context, or exclusions are provided. The description is purely a one-line action statement with no 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the plugin requirement but does not state whether the operation is destructive, whether it checks pin compatibility, what the result of a successful or failed connection looks like, or any side effects. This is a significant gap for a mutation 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 one concise sentence with a necessary caveat about the plugin requirement. There is no fluff or redundant information, making it efficient and front-loaded with the core purpose.

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

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

Given the complexity of graph wiring (5 params, no output schema, no annotations), the description is too brief. It does not explain what a node ID is, how to obtain it (sibling tools like list_graph_nodes could help), what happens after wiring, or any expected return value. The plugin requirement is the only contextual detail, leaving the agent under-equipped.

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

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

Schema coverage is 100% with basic descriptions for all five parameters. The tool description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate. However, the parameters like source_pin and target_pin are only described as 'pin name', without further context on how to format them.

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

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

The description clearly states the action: 'Wire two node pins together in a Blueprint graph.' This uses a specific verb ('wire') and resource ('node pins in a Blueprint graph'), distinguishing it from sibling tools like add_graph_node or remove_graph_node which operate on nodes themselves.

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 by describing the action, but it does not explicitly mention when to use this tool versus alternatives like connect_material_expressions. The only additional guidance is the requirement for the optional C++ plugin, which is a prerequisite rather than 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?

No annotations are provided, so the description must carry the burden. It does not disclose that this likely modifies a material asset, requires compatible pins, or that connections are directional. The behavior beyond the literal action is entirely unspecified.

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 zero redundancy. It immediately communicates the core action and target, making it easy for an agent to parse.

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 5 parameters and no output schema or annotations, the description is too minimal. It does not explain the direction of wiring, default pin behavior, or side effects on the material asset. The agent would need to infer or explore to understand the full context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond restating that two nodes are involved; it does not clarify the roles of from/to expressions or input/output pins. The schema already handles parameter details.

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

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

The description uses the specific verb 'wire' and names the resource 'material expression nodes,' clearly distinguishing it from sibling tools like connect_graph_nodes (which likely targets blueprint graphs) and connect_material_property (which connects material properties). The action and target are unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It simply states the operation without any contextual cues for selection.

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

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

No annotations are provided, so the description must disclose side effects. It only says 'Connect' without mentioning that this modifies the material asset, may require saving, or whether it overwrites existing connections. This is a mutation tool with zero 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?

Single concise sentence that directly states the purpose with useful property examples. No wasted words, perfectly sized.

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

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

The tool modifies a material asset, but there is no output schema and no annotations. The description doesn't explain return values, side effects, or preconditions. Given the mutation nature, it should at least note the need to save or that existing connections are replaced. Not complete for safe invocation.

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

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

Schema coverage is 100%, with descriptions for all four parameters, so the baseline is 3. The description adds nothing beyond the schema; it only lists example properties that already appear in the enum. No additional 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?

Clearly states the action (connect), the entities (an expression and a material output property), and gives concrete examples (BaseColor, Normal, etc.). This distinguishes it from sibling tools like connect_material_expressions, which likely connects expressions to each other.

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 explicit when-to-use or alternatives are provided. The description gives no context about prerequisites (e.g., material must be loaded) or when to prefer this over connect_material_expressions. Usage is only implied by the property list.

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

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

No annotations are provided, so the description must disclose behavioral traits. It reveals that references are replaced but does not state whether source assets are deleted, kept, or otherwise modified, nor any side effects (e.g., if target assets are overwritten). For a potentially destructive operation, this is a significant 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 a single sentence that is concise and front-loaded with the tool's purpose. It contains no filler and every word contributes to understanding the action.

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

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

Given that this is a mutation tool with no annotations and no output schema, the description should explain the full impact, such as whether source assets are removed, whether the target is permanently modified, and if there are any constraints (e.g., related packages). The current description leaves this ambiguous, making it incomplete for an operation that could have significant consequences.

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

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

Schema description coverage is 100%, with both parameters clearly described in the schema (target_path: 'Target asset path to keep', source_paths: 'Source asset paths to consolidate into target'). The description adds minimal extra meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action: 'Consolidate duplicate assets' and specifies the mechanism: 'replace references from source assets to a target asset.' This distinguishes it from sibling tools like fix_redirectors (which fixes broken references) and import_asset (which imports new assets). However, it could be slightly more explicit about the scope (e.g., all duplicates in the project) but is adequate.

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

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

The description implies when to use this tool (when there are duplicate assets to merge) but does not explicitly contrast with alternatives or state when not to use it. There is no mention of prerequisites like whether the source and target must be in the same package. The intended context is implied but not spelled out.

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 discloses the execution mechanism ('runs ContentAudit commandlet') and the nature of the task (finding costly/problematic assets), suggesting a read-only analysis. However, it doesn't state whether the audit modifies assets, requires specific permissions, or produces a detailed report, leaving important behavioral traits unspecified.

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 that efficiently conveys purpose and execution. Every word adds value, with no redundancy or extraneous information. It is appropriately sized for a zero-parameter 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?

Given the tool has no parameters, no output schema, and no annotations, the description is the sole source of information. It covers what the tool does and how it executes, but it does not clarify what the agent should expect as a result (e.g., a list of assets, console output, or a report). This gap prevents full contextual completeness for an agent invoking the tool.

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

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

The input schema has zero parameters (empty object), so parameter semantics are not applicable. The description correctly omits any parameter explanation. Baseline for 0 params is 4, and the description does not need to compensate for any missing schema details.

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

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

The description clearly states the tool's purpose: 'Run content audit to find costly or problematic assets'. It uses a specific verb ('run') and resource ('content audit'), and the additional parenthetical 'runs ContentAudit commandlet' adds technical specificity. This distinguishes it from siblings like validate_assets or fix_redirectors.

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 does not provide guidance on when to use this tool versus alternatives. It implies usage through its purpose (finding costly/problematic assets), but there is no explicit context, exclusions, or mention of sibling tools. The user is left to infer when 'content_audit' is preferable to tools like validate_assets or consolidate_assets.

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?

There are no annotations, so the description carries the burden. It discloses the function's purpose but does not mention side effects, the impact on existing assets, whether it is destructive (e.g., overwrites files), or any required conditions (e.g., platform availability). Given the mutation potential, this is a significant gap.

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

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

The description is two sentences, concise and front-loaded with the action. It wastes no words but could be slightly more informative about the process. It is efficient and to the point.

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

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

The tool has 3 optional parameters and no output schema. The description covers the basic purpose but does not explain the behavior of 'iterate' or 'maps', nor the return value or side effects. Given the tool's potential complexity, the description is minimally complete but lacks detail about the cook process and dependencies.

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

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

The schema covers 100% of parameters with descriptions, so baseline is 3. The description adds no extra meaning beyond the schema, but it doesn't need to given the schema coverage. Yet, the description could add typical values for platform, but that is optional. Hence a 3 is appropriate.

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

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

The description clearly states the verb 'cook' and the resource 'content', and contrasts with 'no C++ build' to distinguish it from build operations. It also states the outcome: converting assets to platform-specific format. This distinguishes it from build_target and other build/cook siblings.

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

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

The description says 'Cook content only (no C++ build)', implying when to use this instead of a full build. However, it does not explicitly mention when not to use it or suggest alternatives. It lacks context on when to choose this over build_cook_run or package_project.

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 burden. It only says 'Create' without disclosing side effects, potential overwrites, required permissions, or return behavior. This leaves significant ambiguity.

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, concise sentence that conveys the essential purpose without unnecessary detail. It is well-structured and easy to parse.

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 minimal but adequate for a simple creation tool given no output schema or annotations. However, it lacks any mention of success/error behavior or expected outcomes, so it's not fully complete.

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

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

Schema coverage is 100% with each parameter having a description. The tool description itself adds no extra parameter semantics, but since coverage is high, the baseline of 3 applies.

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

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

The description clearly states the tool's purpose: to create an Animation Blueprint for a target skeleton. It distinguishes itself from sibling creation tools like create_level_sequence and create_anim_montage.

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 doesn't mention scenarios where this is preferred or any prerequisites (e.g., requiring a valid skeleton asset).

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 must disclose behavioral traits. It only states the action without mentioning side effects (e.g., asset creation location, overwrites), permission requirements, or how the montage relates to the source sequence. This is a significant gap for a creation 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, succinct sentence that conveys the core action without fluff. It is appropriately front-loaded and avoids redundancy with the schema. However, it is so brief that it borders on under-specification, though it remains clear and purposeful.

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 lack of annotations and output schema, the description is incomplete. It does not explain what happens after creation (e.g., where the montage is saved, whether it is automatically opened, or how to verify success). For a creation tool, this missing context is a notable gap, especially since the tool has multiple parameters and siblings.

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

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

The input schema has descriptions for all three parameters (100% coverage), so the baseline is 3. The description adds no additional meaning beyond the schema, simply restating the relationship between the source and the montage. It does not clarify parameter formats, defaults, or interdependencies beyond what the schema already provides.

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

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

The description clearly states the action ('Create') and the resource ('animation montage') with a source ('from an animation sequence'). It is specific enough to distinguish from related tools like create_anim_blueprint, though it could be slightly more detailed about what a montage represents. Overall, it's a clear 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?

The description provides no guidance on when to use this tool instead of alternatives. It does not mention prerequisites, typical use cases, or exclusions. With many sibling tools for animation and asset creation, this lack of context makes it hard for an agent to select this tool appropriately.

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

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

No annotations are provided, so the description must fully disclose behavior. It only says 'Create a new Blueprint class' without mentioning side effects (e.g., asset creation on disk, automatic compilation, or whether existing assets are overwritten), leaving the tool's behavioral footprint completely unspecified.

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, clear sentence with no wasted words. It is appropriately sized for a simple creation tool, though it is minimal.

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 3-parameter tool with no output schema and no annotations, the description is insufficient. It does not explain what a Blueprint class is, what the tool returns, or any prerequisites or side effects. Sibling creation tools like create_anim_blueprint appear similar, making additional context necessary.

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

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

The input schema provides descriptions for all 3 parameters (name, path, parent_class) with 100% coverage, so the baseline is 3. The description adds no parameter-specific semantics, relying entirely on the schema for 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 uses a specific verb ('Create') and names the resource ('Blueprint class'), clearly stating the tool's action. It is distinguishable from sibling creation tools like create_anim_blueprint or create_material by explicitly naming 'Blueprint class,' though it does not elaborate on what a Blueprint class entails.

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 versus alternatives. The description simply states the action without mentioning exclusions, prerequisites, or related tools such as compile_blueprint or spawn_blueprint_actor, leaving the agent without selection 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?

The description only mentions the creation action without disclosing side effects, error conditions, or permissions. It does not state what happens if the asset already exists or any other behavioral aspects.

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, concise sentence that directly states the purpose. It is well-structured and front-loaded with the key information.

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

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

For a simple creation tool, the description is adequate but incomplete. It does not mention any return values or output, nor does it provide context on the asset's properties or interactions with other systems.

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

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

The schema already covers all parameters with descriptions (name, path). The tool description adds no extra meaning beyond what the schema provides, so it meets the baseline but does not exceed it.

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

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

The description clearly states the action (create) and the resource (LevelSequence asset) with a specific purpose (for cinematics). It is unambiguous and distinguishes it from other tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or comparison with sibling tools.

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

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

With no annotations available, the description carries the full burden of behavioral disclosure, but it only states the core action. It does not mention what happens if a material with the same name exists, whether a default path is used, or any side effects of asset 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 a single, focused sentence with no redundancy or filler. It efficiently communicates the tool's purpose without unnecessary detail.

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

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

The tool is simple with only two parameters and a clear schema, and the description states the basic purpose. However, it lacks usage guidance and behavioral details that would make it fully self-sufficient, especially given the absence of annotations and 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?

The input schema already provides 100% coverage of the two parameters (name and path), including descriptions and defaults. The description adds no parameter-specific guidance, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Create') and identifies the resource type as 'material asset', which clearly distinguishes it from sibling tools like create_material_function and create_material_instance. It is concise and not tautological.

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 such as create_material_instance or apply_material. There is no mention of prerequisites, exclusions, or context in which this tool is preferred.

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

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

No annotations are provided, so the description carries the full burden. It states the action but does not disclose side effects, whether a material must already exist, behavior on invalid paths, or any error conditions. For a mutating operation, this is a significant 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?

A single, clear sentence that front-loads the action and resource, followed by useful examples. No wasted words.

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

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

For a simple node-adding tool, the description is minimally sufficient, but it lacks context about how this fits into a broader workflow (e.g., adding a node is separate from connecting it). No output schema or annotation support increases the burden, but the operation itself is straightforward.

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

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

The schema already provides descriptions for all parameters (100% coverage), so the baseline is 3. The description adds value by giving concrete examples of valid expression_class values, but does not elaborate on x/y placement semantics beyond the schema.

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

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

The description uses a specific verb ('Add') and resource ('expression node to a material's graph'), with concrete examples (TextureSample, Multiply, Constant3Vector). This clearly distinguishes it from sibling tools like create_material or connect_material_expressions.

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 purpose implies usage (add a node to a material graph), but no explicit guidance is given about when to use this tool versus alternatives like add_graph_node or connect_material_expressions. The description does not mention exclusions or prerequisites.

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 provided, the description carries the full burden of disclosing behavioral details. It only says 'create', without mentioning side effects such as whether the function is saved immediately, if existing ones are overwritten, or any permissions needed. The word 'reusable' adds minimal context but is inherent to the asset type.

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

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

The description is a single sentence with no unnecessary words, making it concise and front-loaded. It is efficient, though it could arguably provide more substance without losing brevity.

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 simple tool (2 parameters, full schema coverage) and no output schema, the description adequately states the core purpose. However, the absence of annotations and behavioral context means the agent must infer what 'create' entails, such as saving behavior or overwrite policies, which could be ambiguous.

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

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

The input schema has 100% coverage with descriptions for both 'name' and 'path'. The description does not add any additional meaning beyond the schema, but the baseline is 3 because the schema already documents parameters well.

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

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

The description uses a specific verb 'create' and identifies the resource as a 'reusable material function', which clearly differentiates it from siblings like create_material or create_material_expression by the asset type. However, it doesn't explicitly contrast with these alternatives, so it lacks full sibling differentiation.

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

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

There is no guidance on when to use this tool versus other creation tools. The description simply states the action without any context, prerequisites, or exclusions, leaving the agent to infer usage from the resource type.

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 of behavioral disclosure, but it only states the core action. It does not mention prerequisites (e.g., parent material must exist), overwrite behavior, or what side effects occur, making it insufficient for understanding the tool's full 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 single-sentence description is concise and front-loaded with the verb and object. Every word adds value, with no filler or repetition.

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

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

Given the tool's moderate complexity and lack of annotations/output schema, the description is minimal but functional because the schema fully documents parameters. However, it lacks usage context and sibling differentiation, making it slightly below average for completeness.

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

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

Schema coverage is 100%, with each parameter described (name, path, parent_path). The description adds no additional parameter semantics beyond saying 'from a parent material,' which mirrors the parent_path description. 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 'Create a material instance from a parent material' clearly identifies the action (create), the resource (material instance), and the source (parent material). This distinguishes it from sibling tools like create_material or create_material_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 such as create_material or apply_material. The description only states what it does, leaving the agent to infer usage context from the name alone.

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 must carry the full burden. While 'Delete' implies a destructive operation, it does not disclose whether the deletion is reversible, what happens to references, or any side effects. This leaves a significant transparency 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?

A single, tightly worded sentence communicates the core action, target, and selection criteria with no redundancy or filler.

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

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

For a simple tool with one parameter and no output schema, the description covers the basic purpose and parameter. However, the lack of usage guidance and behavioral transparency for a destructive action makes it only minimally complete.

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

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

The schema description coverage is 100%, and the parameter description already states 'Actor name or label to delete'. The tool description reinforces this but does not add new meaning beyond the schema, meriting the baseline score.

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

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

The description 'Delete an actor from the current level by name or label' uses a specific verb with a clear resource (actor) and scope (current level). It distinguishes itself from sibling tools like delete_asset and duplicate_actors by targeting actors specifically.

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 such as delete_asset for assets or select_actors for selection. The description lacks explicit context, exclusions, or alternative tool references.

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 provided, the description carries the full burden. It discloses the key safety behavior of checking references before deletion, but does not explain what happens when references exist (e.g., error unless force) nor mention other consequences like irreversibility or permission requirements. This is better than nothing but incomplete.

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

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

The description is two short sentences with no fluff. It is front-loaded with the primary action and immediately provides a critical behavioral note. Every word earns its place.

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

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

For a simple delete tool, the description covers the core purpose and a critical behavioral aspect. The schema documents all parameters, and since there is no output schema, return values are not necessary to explain. It could mention potential error conditions or confirmation prompts, but given the simplicity, it is fairly complete.

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

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

Schema coverage is 100%, so the parameters are fully described in the schema. The tool description adds value by explaining the rationale for the force parameter: it relates to the reference check. This connects the parameter to the real-world behavior, going beyond the schema's literal 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 clearly states the action ('Delete') and the resource ('an asset'). It distinguishes itself from sibling tools like delete_actor (which targets actors) and provides a specific behavioral detail ('Checks for references first') that adds 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?

The description implies usage when an asset needs to be deleted, but it does not explicitly state when to use this tool versus alternatives like rename_asset or delete_actor. The reference-check behavior hints at a prerequisite but no exclusions or alternative suggestions are provided.

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 present, so the description must carry the behavioral burden. It only says 'Remove an expression node' without disclosing side effects like breaking connections, irreversibility, or whether the material needs recompilation. This is a simple restatement of the tool's name.

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 concise sentence that is front-loaded with the verb and resource. No wasted words or unnecessary detail.

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

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

For a simple delete tool with two well-documented parameters and no output schema, the description is adequate. It identifies the specific domain (material graph) and the operation, which is sufficient for an AI agent to select and invoke the tool.

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

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

Schema description coverage is 100%, with both 'material_path' and 'expression_name' having clear descriptions. The tool description adds no additional parameter context, so the baseline of 3 is appropriate.

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

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

The description 'Remove an expression node from a material graph' uses a specific verb ('Remove') and explicitly identifies the resource ('expression node from a material graph'). This clearly distinguishes it from sibling tools like 'delete_asset' and 'remove_graph_node'.

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 does not explicitly state when to use this tool versus alternatives such as 'remove_graph_node' or 'delete_asset'. Usage is implied through the material graph context, but no exclusions or alternative references are provided.

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 provided, the description carries the full burden of disclosing behavior. It identifies the file being modified (.uproject) and the post-action requirement (editor restart), which are critical for safe use.

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 highly concise: two short sentences with no redundant information. The action and consequence are front-loaded, making it easy to parse.

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

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

For a single-parameter tool with no output schema, the description provides all essential context: what it does, where it acts, and what the user must do after. It is complete for the tool's simplicity.

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

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

The schema covers the only parameter (plugin_name) with a clear description. The tool description does not add additional parameter-specific context, so the baseline score of 3 applies given 100% schema coverage.

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

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

The description clearly states the action ('Disable a plugin') and the target resource ('.uproject file'). This specific verb+resource combination distinguishes it from sibling tools like enable_plugin and list_plugins.

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 notes a practical consequence (requires editor restart) but does not explicitly discuss when to use this tool versus alternatives like enable_plugin. The intended use is implied rather than stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure and falls short. It doesn't explain what 'duplicate' entails (e.g., does it copy tags, transforms, bindings?), whether original actors are modified, or any side effects. The brief statement is minimally transparent for a tool that likely mutates the scene.

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, short sentence that is immediately scannable. However, it may be too terse—while it earns points for front-loading, it sacrifices substance for brevity, as noted in other dimensions.

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

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

For a simple tool with full schema coverage and no output schema, the description is minimally adequate but leaves gaps. It doesn't clarify return behavior or side effects, and the presence of a nested 'offset' object suggests some complexity that isn't addressed. Given the rich sibling context (Unreal engine automation), more context about what 'actors' are in this tool's domain would help.

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

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

Schema description coverage is 100%, so both parameters ('names' and 'offset') have descriptions in the schema. The description adds 'by name' which clarifies that 'names' refers to actor names/labels, but the 'offset' parameter is already self-explanatory. No additional semantics are provided 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 'Duplicate actors by name' clearly states the action (duplicate) and target (actors), and the 'by name' qualifier adds some scope. It's clear and specific, though it doesn't explicitly distinguish from siblings that might also duplicate since some sibling names like 'add_actor_binding' suggest related but different operations.

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

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

No guidance is given on when to use this tool versus alternatives. The description implies it duplicates actors, but there's no mention of prerequisites, position in a workflow, or why one might choose this over related operations like 'add_actor_binding' or 'spawn_niagara_attached'.

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 provided, the description carries the full burden for behavioral disclosure. It does not mention what happens if the destination path already exists, whether references are updated, or any failure modes. The description only states the basic action without side effects or constraints.

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

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

The description is a single, clear sentence with no redundant words. It is front-loaded with the core action and resource, making it easy to scan. It could be more detailed, but that is a completeness issue, not a conciseness issue.

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 extremely sparse for a tool with no output schema and no annotations. It does not clarify key details such as whether destination_path must include a new asset name, how collisions are handled, or whether the operation is recursive. This leaves the agent with unanswered questions for a mutation operation.

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

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

Schema description coverage is 100%, so both parameters (source_path and destination_path) are already documented in the schema. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Duplicate' with a clear resource ('an asset') and outcome ('to a new path'). It clearly distinguishes from sibling operations like rename_asset or delete_asset, which have different intents.

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 such as rename_asset, import_asset, or duplicate_actors. There are no exclusions, prerequisites, or example 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states that the operation modifies the .uproject file and requires an editor restart to take effect, which is a key side-effect. It does not mention potential errors or permission requirements, but for a simple config-enabling tool this is adequate.

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

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

The description is a single sentence of 14 words, front-loaded with the verb and resource. It contains no redundancy or extra fluff, earning its place entirely.

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

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

For a one-parameter tool with no output schema, the description adequately covers the purpose and the critical restart requirement. It is complete enough for an agent to invoke the tool correctly, though it omits minor details like error handling or whether the plugin must be installed first.

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

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

The input schema has 100% coverage for the sole parameter 'plugin_name', with its own description. The tool description adds no additional parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'Enable' and clearly identifies the resource as 'a plugin in the .uproject file'. This distinguishes it from sibling tools like disable_plugin and list_plugins, making the tool's purpose unambiguous.

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

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

The description implies the tool is used when you want to activate a plugin, and the note about requiring an editor restart provides practical usage context. It does not explicitly name alternatives, but the purpose is clear enough that an agent can infer when to use it in the plugin management workflow.

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 provided, the description must disclose behavioral traits. It only states 'Run a console command' without mentioning potential side effects, that arbitrary commands may modify editor state, or whether output is returned. This is insufficient for a mutating action, especially given no annotations.

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

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

The description is a single, front-loaded sentence that gets straight to the point. Every word is necessary, with examples that are brief and illustrative. No fluff or redundant content.

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

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

For a simple tool with one parameter and no output schema, the description is adequate but lacks details about return behavior, authentication, or potential limitations. Given the existence of a sibling run_stat_command, the description could clarify its scope further, but it is minimally complete.

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

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

The schema fully documents the 'command' parameter, and the description adds concrete example commands ('stat fps', 'stat unit', 'r.SetRes 1920x1080') that clarify the expected string format, providing 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 clearly states the tool runs console commands in the Unreal Editor, with specific verbs ('Run'), resource ('console command'), and concrete examples. It distinguishes from siblings like execute_python (Python execution) and run_stat_command (likely a subset) by being the generic console command tool.

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

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

The description implies usage for any console command via examples but does not explicitly state when to use this over the sibling run_stat_command, which might be more appropriate for stat commands. There are no explicit exclusions or mentions of alternatives, leaving the selection ambiguous.

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 of behavioral disclosure. While it mentions arbitrary code execution and access to the full `unreal` module, it does not disclose potential side effects (e.g., modifying assets, saving packages, or crashing the editor) or error handling behavior. This is a significant gap for a tool with such broad capabilities.

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

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

The description is two sentences, front-loaded with the core purpose, and contains no fluff. Every word earns its place, making it highly concise and well-structured.

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

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

Given the tool's relative simplicity (single parameter, no output schema, no annotations), the description is minimally adequate. It explains the purpose and scope but lacks details on return values, error behavior, or how to retrieve output (e.g., print statements). For a generic code execution tool, this is arguably sufficient, but it could be more informative for a broader audience.

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

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

The schema covers 100% of the parameter (code), including its description ('Python code to execute in the editor'). The tool description itself adds no additional meaning beyond what the schema already provides, so it stays at the baseline for high schema coverage.

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

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

The description clearly states the tool executes arbitrary Python code in the Unreal Editor's Python environment, with access to the full `unreal` module. This specific verb+resource clearly distinguishes it from sibling tools that perform specific operations like applying materials or running tests.

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

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

The description implies this tool is for custom logic not covered by other, more specific tools, but it does not explicitly say when to use it versus alternatives or when not to use it. No exclusions or alternative recommendations are provided, so the guidance is minimal but not misleading.

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 bears the full burden of explaining behavioral traits. It fails to disclose whether the operation is read-only or potentially destructive (e.g., does it overwrite existing output files?). It doesn't explain what happens on failure, whether directories are created, or any side effects. For a tool that writes to disk, this is a significant transparency 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 a single, focused sentence that is brief and folds into the JSON payload cleanly. It's not verbose and is easily scannable. However, its brevity comes at the cost of missing opportunities for elaboration on nuances like file extension handling, which could be covered in one or two more sentences without becoming bloated.

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 complexity of the tool as an export operation, the description is underspecified. It lacks details on supported output formats, whether the output file's extension dictates the format, and how it differs from similar file operations. Since there's no output schema and no annotations, the description should carry more weight in explaining return behaviors, but it doesn't.

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

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

The schema has 100% parameter description coverage with both parameters described. However, the description itself adds nothing beyond the raw schema. The parameter descriptions are minimal: 'Asset to export' and 'Output file path on disk' provide the bare minimum. Since schema coverage is 100%, the baseline of 3 applies, but the thin descriptions like 'Asset to export' are terse.

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 'Export an asset to an external file format' has a specific verb and resource, and the parameters clarify the user provides an asset path and output path. However, it doesn't distinguish itself from the sibling 'import_asset' beyond the direction of transfer, which is implied. It clearly states the verb 'export' and the resource 'asset,' which is adequate but not exceptional.

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 context on when to use this tool versus alternatives. Given the broad set of sibling tools including 'import_asset', 'consolidate_assets', 'validate_assets', and 'run_gauntlet', explicit guidance on when to choose export_asset would be valuable. There's no mention of supported file formats, typical use cases, 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?

With no annotations provided, the description is solely responsible for disclosing behavior. It only says 'export a level sequence to FBX' without mentioning side effects like overwriting the output file, whether it modifies the source sequence, error conditions, or any permissions required. This lack of disclosure is a notable 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?

A single sentence with no extra words. It states the action directly and efficiently. The brevity is appropriate for what is otherwise a straightforward export operation.

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 simplicity (2 parameters, no nested objects, no output schema), a minimal description may suffice. However, the absence of annotations and any extension around usage or behavior leaves it just above minimal viability, but it is not exceptional.

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

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

The schema describes both parameters completely (100% coverage) with names and descriptions ('LevelSequence asset path' and 'Output FBX file path'). The description doesn't add any extra semantics, and since the schema already carries the load, a baseline of 3 is appropriate.

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

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

The description clearly states the action ('Export'), the resource ('level sequence'), and the output format ('FBX'). This specificity distinguishes it from generic tools like 'export_asset' or 'render_sequence', even though the description doesn't explicitly compare with them.

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

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

The description gives no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, scenarios, or comparisons with siblings such as 'export_asset' or 'render_sequence'. This leaves the agent without context for selecting between related defaults.

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 bears full responsibility for behavioral transparency. It mentions 'clean up' and the commandlet, implying asset modification, but lacks detail on side effects, irreversibility, or whether saves are required.

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, concise sentence that efficiently conveys the tool's purpose without extraneous information.

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

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

For a simple tool with no inputs, the description is largely complete. It could mention potential effects like saving changes, but overall it sufficiently covers the tool's role in the pipeline.

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

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

The tool has no parameters, so the schema provides no information. The description adds no parameter details, but since there are none, this is not a gap. The baseline for high schema coverage applies.

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

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

The description clearly states the action (clean up), the target (asset redirectors), and the context (in the project). It also references the underlying commandlet (FixUpRedirects), making the purpose unambiguous and distinct from other tools.

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

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

The description does not provide any guidance on when to use this tool versus alternatives, nor does it mention prerequisites, side effects, or typical scenarios. Users must infer usage from the purpose alone.

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 full burden for behavioral disclosure. It doesn't mention if the operation is destructive (replaces existing collision), requires specific permissions, or affects the asset's save state. It also doesn't clarify what the 'auto' type does or if it modifies the asset in place. This is insufficient for a tool that likely modifies assets.

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, short sentence that directly states the purpose. It's appropriately concise and front-loaded, with no redundancy or filler.

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

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

Despite full schema coverage and a clear verb, the description lacks crucial workflow context. For a tool that likely modifies assets, it doesn't mention if it's reversible, if it requires a loaded project, or if it's part of a larger pipeline. Sibling tools suggest this is an Unreal Editor automation tool, but without annotations or output schema, the description should explain more about what happens after generation.

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

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

Schema description coverage is 100% for both parameters. The description adds value by stating the action on 'mesh_path', but it doesn't add any additional meaning like format constraints or example paths. Since the schema is thorough, baseline 3 is appropriate; the description doesn't elevate it.

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

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

The description states the action (generate collision) and resource (static mesh) clearly, but it's brief and doesn't distinguish from sibling tools like validate_assets or import_asset, though it is unique among the listed siblings. It doesn't specify what type of collision or any further nuance, so it's clear but not detailed.

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. It doesn't mention prerequisites like the mesh being imported, or that this should be used before baking or cooking content. The description just says 'Generate collision' without context on scenarios 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?

There are no annotations, so the description must disclose behavioral traits. It only states the action without mentioning side effects (e.g., modifying the mesh asset, overwriting existing UVs, need to save, or any destructive implications). This lack of transparency for a mutation-like tool is a significant 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 a single concise sentence that fully conveys the core purpose. No fluff or redundant information; every word earns its place.

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

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

With no output schema and no annotations, the description leaves critical gaps: it does not state whether the mesh asset is modified in-place, whether existing UVs are overwritten, any prerequisites (e.g., mesh must be static, accessible), or error conditions. Given the mutation-like nature, more context is needed.

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

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

The schema description for mesh_path is 'Static mesh asset path', which is unambiguous. The tool description adds no further meaning beyond the schema, so baseline 3 is appropriate given 100% coverage.

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

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

The description clearly states the action (generate lightmap UVs) and the target resource (static mesh). It is specific and distinguishes from sibling tools like generate_collision or apply_material, as no other tool mentions lightmap UV generation.

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, prerequisites, or conditions under which it should be invoked. The description is purely declarative without contextual usage instructions.

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 full burden. It only states 'Generate LODs' without disclosing whether existing LODs are overwritten, whether the mesh must be saved, or other side effects. This is insufficient for a mutation operation.

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, efficient sentence with no redundant information. It is well-structured and front-loaded, making it easy to parse.

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 mutation nature and lack of annotations or output schema, the description is too minimal. It doesn't explain the LOD generation process, requirements, or effects, leaving the agent without enough context for confident use.

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 provides complete descriptions for both parameters (lod_count and mesh_path). The description adds no additional parameter semantics beyond what the schema already includes, so baseline 3 applies.

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

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

The description clearly states the tool generates LODs for static meshes, using a specific verb and resource. It distinguishes from sibling tools like set_skeletal_mesh_lod, which targets skeletal meshes.

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 alternatives. It doesn't mention prerequisites, differences from similar tools, or that it only applies to static meshes while set_skeletal_mesh_lod should be used for skeletal meshes.

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 (readOnly/destructive) are present, so the description carries full burden. It says 'Regenerate' which communicates a write operation, but does not disclose whether files are overwritten, if arbitrary settings/options are preserved, or if source paths are required. This is ambiguous for a regeneration action.

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 concise sentence, front-loaded with the core verb. No wasted words, no restating of schema because there is no schema.

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

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

The description gives the tool's scope (IDE files for 3 named IDEs) and a rough action, but no output schema, no mention of file targets beyond IDE type, no prerequisites like opened project/solution, and no side-effects/consequences are explained. For a 0-param tool, it remains merely viable.

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?

Input schema is empty with first-level schema coverage at 100%? Actually properties is empty (no params). Param info is irrelevant; the description adds parameter-specific operational details. Baseline 4 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?

Description uses specific verb 'Regenerate' and resource 'IDE project files (Visual Studio, Xcode, Rider)', clearly distinguishing from sibling tools focused on execution or testing. However, it doesn't contrast with related project file tools like 'build_project' or 'package_project'.

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

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

The usage context is implied: regenerate project files when needing to refresh IDE project structure. It lists target IDEs but gives no explicit when-to-use or when-not-to-use guidance, and doesn't name 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?

No annotations are provided, so the description bears full responsibility for disclosing behavior. It only states a read-only listing action, but does not mention what happens if the actor is not found, whether the list includes nested components, or any side effects. For a simple get operation, it adds minimal behavioral context beyond the name.

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, concise sentence with no filler. It gets straight to the point, making it easy to parse quickly.

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

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

For a tool with one parameter and no output schema or annotations, the description gives the core purpose but omits return format (e.g., names, types), error behavior, and any filtering options. It is minimally viable but leaves gaps about what the returned list contains.

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 for the single parameter 'name' is 100% (description: 'Actor name or label'), so the schema fully documents it. The tool description adds no extra meaning to the parameter, but since the schema already covers it, the baseline of 3 is appropriate.

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

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

The description 'List all components on an actor' clearly states the specific action (list) and the resource (components) with the target (actor). It effectively distinguishes itself from sibling tools like get_actor_properties (properties vs components) and list_actors (all actors vs components of one actor).

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

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

The description implies usage: call this when you need to see components belonging to an actor. However, it provides no explicit guidance on when to use this versus alternatives, nor any exclusions or prerequisites. It doesn't mention whether the actor must exist or how it relates to tools like get_actor_properties.

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 provided, the description carries full burden. The verb 'Get' implies a read operation, but the description does not disclose behavior for edge cases (e.g., actor not found), return format, or whether the operation has side effects. For a simple getter, this is adequate but lacks explicit behavioral detail compared to more transparent descriptions.

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, concise sentence that immediately communicates the tool's purpose. It is appropriately sized for a simple getter operation, with no unnecessary words or repetition.

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

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

The tool has one parameter, complete schema coverage, and no output schema or annotations. The description fully covers the purpose and input, making it self-contained for an agent. It could arguably mention return format, but given the simplicity and lack of output schema, the description is sufficiently complete.

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

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

The schema description coverage is 100% (the parameter 'name' has a description 'Actor name or label'). The description of the tool itself adds no additional parameter semantics beyond this, so the baseline score of 3 per the rubric applies.

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

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

The description clearly states the tool's function: 'Get all properties of an actor by name.' It uses a specific verb ('Get') and resource ('actor properties'), and distinguishes itself from sibling tools like get_actor_components and set_actor_property by focusing on properties rather than components or writes.

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: it is for retrieving actor properties when needed. However, it provides no explicit guidance on when to prefer this tool over alternatives (e.g., get_actor_components) or when not to use it. The context of 'Get' suggests read-only retrieval, but no alternatives or exclusions are stated.

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

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

The description clearly implies a read-only operation ('Get info') and gives some output categories, but it does not disclose error behavior, path validity requirements, or return format details. With no annotations, this is minimal but not misleading.

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 that conveys the tool's purpose and key output details with no filler or redundancy.

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

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

For a one-parameter, no-output-schema tool, the description provides enough context: what it targets and what informational categories to expect. It could be stronger on error cases or path format, but the simplicity of the tool makes this 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?

The single parameter is fully described in the schema as an 'AnimSequence asset path', so the description adds no additional semantic value beyond the schema. This matches the baseline for high schema coverage.

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

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

The description states a specific verb ('Get info') and resource ('animation sequence'), and enumerates the returned data categories (length, frames, bone data). The qualifier 'animation' helps distinguish it from the sibling get_sequence_info tool.

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

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

Usage context is implied: use this when you need metadata about an animation sequence. However, it does not explicitly state when not to use it, nor does it name alternatives such as get_sequence_info for non-animation sequences.

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 says 'detailed metadata' but discloses no behavior beyond that. Since no annotations are provided, the description carries the full burden, and it fails to mention that this is a read-only operation, what specific metadata fields are returned, or how the tool behaves when the asset path is invalid. This leaves the agent guessing about the tool's actual behavior.

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

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

The description is a single sentence that is front-loaded and free of fluff. It earns high marks for conciseness, though the phrase 'detailed metadata' is vague and could be more informative without adding length.

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

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

Given that there is no output schema and no annotations, the description must compensate by explaining what 'detailed metadata' entails and what the return format is. It does neither. For a simple getter with one parameter, this is a significant gap: the agent cannot reliably know what information will be available after calling the tool.

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

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

The input schema covers the single parameter fully, including a clear description and example. The description adds no additional meaning beyond the schema, but per the rubric, high schema coverage (100%) yields a baseline of 3. There is no extra semantic value provided.

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

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

The description clearly states the tool's action ('Get') and target ('detailed metadata for an asset'), which is specific enough to distinguish it from sibling tools like list_assets. However, it doesn't explicitly contrast with similar asset-query tools such as search_assets or get_asset_references, 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?

No guidance is provided on when to use this tool versus alternatives. The description only states what the tool does, with no mention of use cases, prerequisites, or exclusions. Sibling tools like search_assets and get_asset_references occupy overlapping space, but no differentiation is given.

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

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

With no annotations, the description carries the full burden. It does not disclose whether the graph is direct or transitive, whether it includes both hard and soft references, or what the response structure looks like. The term 'graph' is vague without further 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 a single sentence that immediately states the action and subject, with no unnecessary words or filler. It is efficiently 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?

Given the tool has no output schema and no annotations, the description needs to convey more about the graph semantics (depth, format, inclusivity). A two-parameter tool still requires explanation of what 'dependency and referencer graph' entails to be fully usable.

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 no parameter-level meaning. asset_path is minimally described in the schema, and direction is only self-evident through its enum values. With 50% schema coverage, the description should compensate but does not.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('dependency and referencer graph for an asset'). It distinguishes itself from siblings like get_asset_info and search_assets by focusing on graph relationships.

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

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

The intended usage is implied—when you need to know an asset's dependencies or referencers—but no explicit alternatives or when-not-to-use guidance is given. It does not contrast with similar content-auditing 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?

No annotations are present, so the description carries the full burden. It states what info is retrieved but does not disclose that the operation is read-only, whether any errors are possible, or what happens if the blueprint_path is invalid. Even though 'Get' implies a query, the description lacks explicit 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 a single, focused sentence that front-loads the core purpose and lists the included info categories. No redundant or filler content exists.

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

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

There is no output schema, so the description must convey return value expectations. It lists five key categories (class, variables, functions, components, graphs), which gives a reasonable sense of the response content. However, it does not specify the format or nesting, which keeps it just short of complete.

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

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

The input schema fully documents the only parameter, blueprint_path, with its description 'Blueprint asset path'. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the action ('Get') and the resource ('Blueprint info'), and enumerates the specific categories of information included (class, variables, functions, components, graphs). This distinguishes it from sibling tools like get_asset_info or get_actor_properties, which target different 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 is provided on when to use this tool versus alternatives. It does not mention contexts such as inspecting a Blueprint before editing, nor does it exclude cases like non-Blueprint assets. The agent must infer usage from the name and description.

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 of behavioral disclosure. It does not clarify whether this is a safe read operation, whether side effects occur, or what happens on malformed input. The phrase 'the last build output' is ambiguous — unclear if the tool maintains state or if 'last' refers to the provided log. The description presents the function as a pure parser, but this is implied rather than explicit.

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

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

Two tightly written clauses pack in the verb, resource, and output type without waste. Every word earns its place; it is efficiently front-loaded and instantly scannable.

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 an extremely simple single-parameter tool with no output schema and no annotations, the description is mostly adequate but relies heavily on the agent assuming this is a pure function. It never explains the error format for unparseable input, or whether the original raw log is returned alongside structured errors. For a tool with this complexity, the description is acceptable but leaves edge-case behavior to the agent's imagination.

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

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

Schema coverage is 100%, so a baseline of 3 applies. The description adds value by telling the agent that the `build_log` parameter is the raw input to be parsed for structured output, effectively linking the parameter to its purpose. While not drastically exceeding schema, it does reinforce the parsing semantics and the return shape, justifying a 4.

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

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

The description clearly states the verb 'Parse' with the resource 'the last build output' and what it returns: 'structured errors, warnings, and progress.' This distinguishes it from siblings. However, the tool name suggests 'get' (fetch status) while the description emphasizes parsing raw log input, creating a mild name/description mismatch that costs a point.

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 usage guidance is provided. The description does not state when to use this tool instead of siblings like `get_test_results` or `build_target`, nor does it mention prerequisites (e.g., that a build must have been run first). Clear context is implied but not stated.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well by specifying the exact transports interrogated (Remote Control, Python, Plugin Bridge), which adds concrete disclosure beyond a generic status check. However, it does not describe edge cases like the behavior when no transports are connected or the return value shape, which would round out transparency for this zero-annotation scenario.

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 14-word sentence that front-loads the action and resource, with the parenthetical efficiently enumerating the specific transports. Every word earns its place; no wasted verbiage or irrelevant details.

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

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

Given its low complexity (0 params, no schema, no annotations), the description covers the essential purpose fully, and the sibling list containing `sc_status` and `get_build_status` highlights how the explicit transport list helps disambiguate. However, it could note return value semantics (e.g., does it return a simple boolean, a list, etc.) since no output schema exists, which would make it fully complete.

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

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

The tool has zero parameters, so the schema provides no room for ambiguity. Per the rubric, 0 parameters merits a baseline score of 4, and the description appropriately avoids inventing parameter details that don't exist.

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

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

The description uses a specific verb ('Check') and resource ('Unreal Engine transports currently connected'), and lists the exact transports (Remote Control, Python, Plugin Bridge) that distinguish it from siblings like `get_build_status` and `sc_status`. The parenthetical adds precision without ambiguity, making its purpose immediately clear.

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 through its imperative 'Check' but provides no explicit guidance on when to use this tool versus alternatives, nor does it name any sibling for comparison. For a simple status-check tool, the usage context is fairly self-evident from the name and description, but the rubric's requirement for explicit when/when-not/alternatives is not met.

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, and the description only states 'Query' without disclosing behavioral traits such as whether it is read-only, performance implications, or what constitutes 'currently loaded' cells. The agent gets no additional context beyond the tool name.

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

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

The description is a single, tightly worded sentence with no fluff. Every word contributes to stating the tool's purpose, making it highly concise and front-loaded.

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

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

The description is minimal but sufficient for a simple query tool with no parameters and no output schema. However, it omits any detail about the return format or what constitutes 'currently loaded' cells, leaving some ambiguity for the agent.

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

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

There are no parameters, and the schema is empty with 100% coverage (vacuously). Per guidelines, a no-parameter tool receives a baseline score of 4, and the description adds no parameter details because none are needed.

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

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

The description clearly states the action (Query) and the resource (currently loaded world partition cells). It is specific and distinguishes itself from sibling tools, none of which appear to query loaded cells.

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 indication of when to use this tool versus alternatives, no prerequisites, no exclusions, and no mention of alternative query methods. The user is left to infer usage context from the name alone.

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 provided, the description carries the full burden of behavioral disclosure. It correctly implies a read-only operation and clarifies the semantic scope of 'details' with the parenthetical, but it doesn't address potential errors (e.g., nonexistent preset), behavior expectations, or any side effects. For a three-word schema ('Preset name'), the description does add resource-type context, but the behavioral disclosure is minimal—comparable to a middling description for an unannotated 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 13-word sentence that front-loads the verb 'Get' and wastes zero words. The parenthetical efficiently disambiguates what kind of details are returned. Every word earns its place; this is a model of concise description 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?

For a low-complexity tool (1 param, simple read operation, no enums or nested objects), the combination of description and full schema coverage paints a complete enough picture. The description explains what's returned (exposed properties and functions) and the schema documents the parameter fully. The only gaps are edge behaviors like error handling for invalid preset names, but for a simple getter with no output schema required, this is appropriately complete.

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

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

Schema description coverage is 100% ('Preset name' for preset_name), so the baseline is 3 per the rubric. The tool description adds no parameter-level semantics beyond what the schema already provides, but it doesn't need to—the schema fully documents the only parameter. This is a case where the schema does the heavy lifting and a 3 is appropriate.

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

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

The description uses a specific verb+resource construction ('Get details of a Remote Control Preset') and the parenthetical ('exposed properties and functions') scopes what 'details' means. It implicitly differentiates from sibling tools like get_preset_property and call_preset_function by indicating the full set of exposed items is returned, though it never explicitly names or contrasts these alternatives. The differentiation is functional but implicit, keeping this just shy 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?

No guidance is given about when to use this tool versus the many related siblings (get_preset_property, call_preset_function, list_presets). While one could infer a workflow of inspecting a preset's exposed members before acting on them, the description never states this. Sibling context suggests a natural 'get info before getting/setting properties' flow, but that connection is left entirely to the reader.

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 full burden. It states the action but does not disclose any behavioral traits such as whether the property is read-only, what happens if the property doesn't exist, or any side effects. For a getter, this is minimal but acceptable; however, it lacks detail on error behavior or return format.

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, concise sentence that front-loads the purpose. No wasted words, and it is appropriately sized for a simple getter 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?

Given the tool's simplicity (2 params, no output schema, no nested objects), the description is adequate but not rich. It doesn't mention what the return value looks like or any prerequisites, but for a basic getter with full schema coverage, it meets the minimum viable threshold.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds no extra meaning beyond the schema, but the baseline is 3 given high coverage. It doesn't clarify the relationship between preset_name and property_name or any constraints.

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

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

The description clearly states the tool gets a property value from a Remote Control Preset, using a specific verb and resource. It distinguishes from siblings like set_preset_property and call_preset_function, though it doesn't explicitly contrast them.

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

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

The description implies usage for reading exposed properties from a preset, but provides no explicit guidance on when to use this vs. alternatives like get_preset_info or set_preset_property. Context is clear but exclusions are absent.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. The verb 'Get' clearly implies a read-only, non-mutating operation, and it discloses what information will be returned. It does not explicitly state that no modifications occur, but for a simple getter this is reasonably transparent. It also does not discuss error conditions or permissions, but these are less critical for a read operation.

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

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

The description is a single, well-structured sentence that is front-loaded with the action and resource. It includes useful clarifications (bindings, tracks, sections) without unnecessary verbiage. Every word earns its place.

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

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

The tool is simple with one parameter and no output schema. The description explains what the tool returns at a high level and gives examples. It covers the essentials adequately for the tool's complexity. While it might mention potential errors or exact output format, these are not required for a straightforward getter, especially given the high schema coverage.

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

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

The input schema has 100% description coverage for the single parameter 'sequence_path', which already states it is a 'LevelSequence asset path'. The description adds 'level sequence' context but does not provide any additional meaning beyond the schema. Baseline 3 is appropriate when the schema already documents parameters fully.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('full structure of a level sequence') with concrete examples (bindings, tracks, sections). This clearly distinguishes it from sibling tools like create_level_sequence or add_track, and from the similar get_anim_sequence_info which targets animation sequences, not level sequences.

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

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

The description implies when to use the tool (when you need the structure of a level sequence) but does not explicitly state exclusions or alternatives. Sibling tool get_anim_sequence_info exists, but the description does not mention that distinction. It provides clear context but lacks explicit when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden. However, it only says 'get the results' with no mention of side effects, permissions, or what happens if no test has run. It implicitly implies read-only behavior but does not explicitly state any absence of side effects or error conditions. For a getter, this is thin.

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 concise sentence with no redundancy or fluff. It perfectly captures the tool's function without wasted words.

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

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

Given the tool has no parameters and no output schema, the description is minimally sufficient, but it lacks context such as what 'results' include (e.g., pass/fail counts, logs), whether the tool is read-only or triggers any side effects, and how it relates to the various automation test runner siblings. For a getter with zero params, this is acceptable but not thorough.

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

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

The tool has zero parametersyears, so the input schema is complete with no undeclared parameters. Per the rubric, a zero-parameter tool gets a baseline score of 4 since there is no missing parameter documentation.

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

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

The description clearly specifies the action (get) and the resource (results of the last automation test run). It distinguishes itself from siblings like 'run_automation_tests_by_category' or 'list_automation_tests' by focusing on retrieval rather than execution or listing. However, it could be slightly more specific about what constitutes a 'test run' (e.g., single test or suite), so not a perfect 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?

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It simply restates the tool's name. There is no mention of needing to run tests first or any context where this should be preferred over other getters.

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, and the description does not disclose any behavioral traits such as side effects, permissions, or error handling. It is a simple get operation, but the lack of any transparency lowers the score.

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, direct sentence with no unnecessary words. It is front-loaded with the verb and clearly conveys the purpose without fluff.

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

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

The description is minimal and does not explain the output format, the range of the history, or any edge cases. Given the simple nature of the tool, it is adequate but leaves room for more context.

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

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

The schema already fully describes the 'count' parameter with a clear description. The tool description does not add additional meaning beyond what the schema provides, so the baseline for high schema coverage applies.

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

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

The description clearly states the action (get) and the resource (undo/redo transaction history), which distinguishes it from sibling tools like undo and redo that perform actions rather than retrieve history.

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 for retrieving undo/redo history but does not explicitly state when to use it over alternatives like undo or redo, nor does it mention any preconditions or 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 annotations are present, so the description carries the full burden. It discloses the read-only nature via 'Get', but does not add context about coordinate systems, units, or edge cases such as when no viewport is open. For a simple getter, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence that efficiently conveys the action and object. No redundant words or information.

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

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

For a parameterless getter with no output schema, the description adequately states what is returned (location and rotation). However, it lacks details on the return format (e.g., vectors, rotators) or coordinate space, which is a minor gap for an agent.

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

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

The tool has zero parameters, so the baseline of 4 applies. The schema is trivially complete, and no additional parameter documentation is required.

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

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

The description clearly states the tool 'Get the current editor viewport camera location and rotation' with a specific verb and resource. It distinguishes from the sibling set_viewport_camera by clarifying it retrieves, not sets, the camera 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 implied usage is to read current camera data, but there is no explicit guidance on when to use it, when not to, or alternatives like set_viewport_camera. The description provides contextual clarity but lacks exclusions or explicit recommendations.

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