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

With no annotations, the description carries the full burden for behavioral disclosure. 'Add' implies graph mutation, but the description does not state that the blueprint asset is modified, whether saving/compiling is needed, whether duplicate nodes are created, or what the tool actually returns. The line 'Returns the absolute... value' refers to the node's runtime behavior, not the tool's response, which could confuse an agent.

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 well-structured and front-loaded: a one-line definition, a brief behavior note, a use case, compact argument descriptions, a KB reference, and a practical example. Every section earns its place without excessive verbosity.

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 node-adding tool, the description provides the essential call information, an example, and a KB link. The presence of an output schema covers return-value specifics. It falls short only in not disclosing side effects or node-connection behavior, which matters for Blueprint graph mutation tools.

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

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

Schema description coverage is 0%, so the description must compensate. It does so meaningfully by documenting operand_type values ('Float' or 'Integer'), noting node_position is an optional [X, Y] graph position, and providing a concrete blueprint_name example. The main gap is that blueprint_name's exact asset-path requirements are only implied by the example.

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-resource pair, 'Add an Abs (Absolute Value) node,' and distinguishes this from the many sibling add_*_node tools by naming the exact node type. The explanatory sentence about absolute value reinforces the tool's purpose without 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 gives a clear use case ('Useful for computing distances and speeds without sign'), so an agent can infer when this tool is appropriate. However, it does not explicitly contrast this with alternatives such as add_math_node or add_blueprint_function_node, nor does it state when not to use it.

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

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

With no annotations, the description carries the full burden, but it only says the node is added and what it is used for; it does not state side effects, prerequisites (e.g., existing Blueprint, lvs_variable must exist), whether the graph is compiled or saved, or failure behavior. The mutation is implied by 'Add' but not characterized in terms of its effects on the Blueprint graph.

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 purpose is front-loaded, the Args list is terse, and the example is concrete. The Ch. 20 context and KB line are slightly redundant, but they add helpful framing rather than bloat.

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 five-parameter mutation tool with no annotations and no parameter descriptions in the schema, the description covers every parameter, offers a KB pointer, and gives a minimal working example; the output schema is available for return-value details. It is complete enough to call correctly, though it would benefit from noting prerequisites and side-effect 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 Args section explicitly defines all five parameters, providing meaning the input schema's bare titles lack: lvs_variable is 'Variable holding the Level Variant Sets reference,' variant_set_name and variant_name are the set and variant to switch, and node_position is '[X, Y] graph position.' This fully compensates for the 0% schema description coverage.

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

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

The description opens with a specific verb and resource: 'Add an ActivateVariant node to switch variants via Blueprint,' and reinforces it with the BP_Configurator context. It does not explicitly contrast itself with the similarly named sibling add_activate_variant_set_node, so it stops 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?

The Ch. 20 note and example imply this is for product-configurator Blueprints that switch variants on button presses, and the example shows a concrete call. However, there is no explicit when-to-use/when-not-to-use guidance or named alternative, leaving the agent to infer the appropriate context from the example.

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, prerequisites, and mutation behavior. It only states that it adds a node and activates variants, without mentioning required existing assets (blueprint, variant set), whether compilation is triggered, or potential errors. 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 well-structured with a title, main purpose, args list, KB reference, and example. It is front-loaded with the core action. There is some redundancy ('From Ch. 20: Activates all variants within a Variant Set' repeats the purpose), but overall it is concise and organized.

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 blueprint node-add operation, the description covers the essential parameters and provides an example. However, it omits prerequisites (e.g., blueprint must exist, variant set must be valid), expected output or return value, and failure modes. The KB reference helps but is not sufficient for full autonomous execution.

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 includes an 'Args' section that explains each parameter: blueprint_name, lvs_variable, variant_set_name, and node_position. This adds meaning beyond the schema, which has no descriptions (0% coverage). The example also demonstrates usage, so parameters are well contextualized.

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 (add) and resource (ActivateVariantSet node), and explains the effect: 'activate all variants in a set.' It distinguishes itself from the singular sibling add_activate_variant_node by emphasizing 'all variants,' but does not explicitly name alternatives. The purpose is clear and specific.

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

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

The description gives a use case ('Useful for resetting or applying a full configuration') but does not specify when to avoid this tool or mention alternatives like add_activate_variant_node for single-variant activation. Usage context is implicit rather than explicit.

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

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

No annotations are provided, so the description must carry full disclosure. It explains that the node uses Delta Location to modify current location, which is helpful but lacks detail on side effects, persistence, or prerequisites. It does not mention whether the operation is additive, if it requires specific actor settings, or what happens if the blueprint already has a similar node. This is adequate but not comprehensive 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 concise and well-structured: purpose, context, arguments, knowledge base reference, and an example. It front-loads the core purpose and avoids redundancy. The only minor issue is that arguments are listed with minimal detail, but overall it is efficient and easy to scan.

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

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

For a node-add tool in a large sibling set, the description covers the essential purpose, usage context, parameters, and a usage example. It distinguishes itself from related tools and provides a KB reference for deeper context. It does not mention return values or graph placement behavior, but given an output schema exists and the tool's simplicity, this is largely sufficient.

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

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

Schema description coverage is 0%, and the description adds only minimal meaning. It restates 'blueprint_name: Blueprint name' and 'node_position: Optional [X, Y] graph position', which barely goes beyond the schema's titles. It does not explain the units, format, or purpose of node_position, nor does it describe the blueprint_name format beyond the example. With zero schema help, this is insufficient for an agent to construct valid parameters.

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

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

The description clearly states it adds an 'Add Actor World Offset' node that moves an actor by DeltaLocation Vector. It uses a specific verb and resource, and explicitly contrasts it with 'SetActorLocation', distinguishing it from a related alternative without needing to inspect the schema.

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

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

It provides explicit usage guidance by noting it is 'More appropriate than SetActorLocation for incremental movement each tick.' This gives a clear condition for when to use this tool over a named sibling, though it doesn't list exclusions or other alternatives. The example also reinforces practical use.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the core semantic behavior (the node additively applies DeltaRotation to current rotation) and gives a concrete example. It does not disclose operational traits such as whether the blueprint is mutated in place, whether compilation is triggered, or failure behavior for a nonexistent blueprint path.

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

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

The description is compact and well-organized into summary, args, KB pointer, and example, with the core action front-loaded. The Ch.14 line slightly repeats the first sentence's DeltaRotation point, but the overall structure 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 2-parameter node-adder with an output schema present, the description covers the essentials: what node is added, the parameters, and a working example. It leaves gaps around error conditions, whether the node's DeltaRotation input requires downstream wiring, and why a CHAOS-physics KB chapter is referenced for a generic rotation node.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: both parameters are explained (blueprint_name as 'Blueprint name', node_position as 'Optional [X, Y] graph position'). The example clarifies that blueprint_name expects an asset path like '/Game/MCP_Test/BP_Example', which the bare schema does not convey.

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 an 'Add Actor World Rotation' node') and the node's function ('rotates actor by DeltaRotation'), grounding the verb and resource clearly. It does not explicitly name sibling alternatives like add_set_actor_rotation_node or add_get_actor_rotation_node, but the additive-rotation semantics distinguish it from 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?

Usage context is implied rather than stated: 'AddActorWorldRotation adds the Delta Rotation to the current rotation' tells an agent this is for relative rotations, not absolute ones. However, with a huge family of rotation/transform node-adders among siblings, there is no explicit when-to-use versus alternative guidance or exclusion criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the operation and parameter meanings. It does not mention side effects, whether existing states are overwritten, required preconditions, or error 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 compact and logically structured with an Args block, a KB reference, and an example. It is front-loaded with the purpose and avoids excessive prose, though the example is somewhat repetitive.

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 KB link and output schema help, but the description still lacks critical context for confident use: prerequisites, whether the state machine must already exist, failure modes, and relationship to sibling animation-state tools. It is not complete enough for an agent to avoid common mistakes.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all four parameters with minimal labels and marks animation_asset as 'Optional animation sequence asset path,' and gives state_name examples. However, most descriptions restate the parameter names and do not provide path/format guidance beyond one example.

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

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

The description clearly identifies the action and target: 'Add an animation state to a State Machine.' It is specific enough to distinguish from related siblings like add_state_machine and add_state_transition, though it does not explicitly call out how it differs from set_animation_for_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?

No when-to-use or when-not-to-use guidance is provided. The description gives an example and parameter list but does not explain whether the state machine must already exist, when to prefer this over set_animation_for_state, or what prerequisites apply.

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

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

With no annotations, the description carries the full burden, yet it only says 'Add a variable'. It does not disclose whether the asset must be open, whether the change immediately mutates/saves the asset, how existing variables are handled, or any failure conditions.

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

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

The description is compact and well organized: summary, Args, KB pointer, and example. The structure earns its place, though the incorrect example adds minor noise and the example repeats the variable name as the type.

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 four-parameter mutation with no annotations, the description is adequate: it identifies the target asset, parameter meanings, and a KB reference. It still omits side effects, naming constraints, and conflict behavior, leaving an agent to infer the full operational contract.

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

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

Schema coverage is 0%, so the Args section supplies meaning for all four parameters, including valid variable_type options and an example for variable_name. However, the example passes 'ExampleName' as variable_type, which contradicts the listed types and could mislead an agent; default_value is only glossed as 'Optional default value'.

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

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

The opening sentence names a concrete action and resource: 'Add a variable to an Animation Blueprint' and adds the intended use ('for use in transitions/logic'). This clearly separates it from generic blueprint variable tools like add_blueprint_variable among the 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 phrase 'for use in transitions/logic' implies when the variable is needed, but the description never says when to prefer this tool over add_blueprint_variable or any other sibling, and it gives no exclusions or preconditions.

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 implies mutation ('Add') but does not state side effects, whether the asset must be loaded/saved first, reversibility, validation of notify_name against the AnimBP, or failure behavior. The KB reference is a pointer, not a behavioral disclosure.

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

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

The description is well-structured: a one-line purpose statement, a clean Args list, a KB reference, and a concrete example. It is front-loaded with the action and every element adds value, though the example partially duplicates the args list.

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 5-parameter tool with 0% schema coverage and no annotations, the description covers all parameters, provides an example, and links to KB documentation. An output schema exists so return values need no explanation. Gaps remain in error conditions and prerequisites (e.g., what happens if animation_path is invalid or the asset is unsaved), but the core calling contract is adequately specified.

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

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

Schema description coverage is 0%, and the description fully compensates: it documents all five parameters with real meaning — path format with example ('/Game/Characters/Run.Run'), notify_name semantics ('Event name to trigger from the AnimBP'), units for time, allowed values for notify_type, and purpose of notify_state_duration. Only minor gaps remain (e.g., not explicitly stating notify_state_duration is ignored for 'notify').

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

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

The description states a specific verb and resource: 'Add an Anim Notify or Notify State to an Animation Sequence or Montage.' This precisely differentiates the tool from animation siblings like anim_add_branching_point, anim_add_montage_slot, and add_animation_state without needing to open schemas. The resource type and target asset class are both explicit.

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 an example call and a KB pointer, which implies usage, but it never states when to use this tool vs. alternatives (e.g., anim_add_branching_point, anim_add_montage_slot) or when not to use it. No exclusions or selection criteria are given, so an agent must infer context from the example 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 behavioral burden. It clearly states the action (adds a node), the node's purpose (string concatenation), and how the parameters feed into it. However, it does not disclose potential side effects, prerequisites like whether the blueprint must already exist, or whether the operation compiles or connects the node.

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 well-structured and front-loaded with the core action. It includes a brief use case, a concise argument list, a knowledge base pointer, and a realistic example. Each section earns its place without unnecessary verbosity.

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-addition tool, the description covers the essential context: purpose, parameters, example, and KB reference. The output schema exists, so not describing return values is acceptable. It lacks some guidance on when not to use it and does not mention required-versus-optional parameters, but the schema covers required fields.

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

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

Schema description coverage is 0%, but the description compensates fully by explaining each parameter: blueprint_name is the target blueprint, string_a and string_b are the A/B pin defaults, and node_position is an [X, Y] graph position. This is significantly more meaningful than the raw schema property names and defaults.

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

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

The description opens with a clear verb and resource: 'Add an Append (string concatenation) node,' and further explains it 'Combines two strings into one.' This is unambiguous and specific. However, it does not explicitly differentiate itself from sibling tools like add_format_text_node or add_print_string_node, though the operation is distinct enough by name.

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

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

The description provides a concrete use case: 'Used to build "Levelled up to " + CurrentLevel display string,' which implies when this tool is appropriate. It does not explicitly state when to use this tool versus alternatives, nor does it give exclusions or mention when another node type would be preferable.

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 says 'Add' a node, which implies a mutation, but it does not mention whether the blueprint is modified in place, whether the graph must be open, whether compilation or saving is required, or what side effects occur. This is a significant transparency 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 short and front-loaded with the core purpose, followed by a compact args section, KB pointer, and example. It avoids unnecessary filler. It could be improved slightly by folding the KB link into a more informative sentence, but the structure is efficient for a 2-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 that there are no annotations and the schema has 0% parameter description coverage, the description leaves important gaps: it does not explain how to specify node_position, whether the blueprint must already exist, what graph context is assumed, or what the operation changes. An output schema exists, so return-value explanation is not required, but the missing parameter and behavioral context makes the definition incomplete.

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

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

Schema description coverage is 0%, so the description must fully document the parameters. It only says 'blueprint_name: Blueprint name' and 'node_position: Optional graph position', which adds little beyond the schema. The example gives a blueprint path, but node_position format, coordinate order, units, and behavior when omitted are not explained.

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 and resource: 'Add an "Apply Damage" node.' It is more than a tautology because it names the exact node type and is distinguishable from nearby siblings like add_apply_point_damage_node. However, it does not elaborate on what the node does or how it differs from similar damage-related nodes beyond the name.

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

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

There is no guidance on when to use this tool versus alternatives such as add_apply_point_damage_node or other add_*_node tools. The example and KB link show how to call it, but the description does not state prerequisites, selection criteria, or when not to use it.

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

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

No annotations are provided, so the description carries the burden. It explains the behavioral effect (damage with hit location/direction enabling physics reactions) and mentions optional node_position. However, it doesn't disclose side effects like whether the node is automatically connected, whether the blueprint is compiled, or whether existing nodes are affected. The KB reference adds some context but is not a substitute for behavioral disclosure.

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

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

The description is compact and front-loaded with the core purpose. The comparison to Apply Damage is useful, and the Args list plus example are efficient. The KB reference is a minor addition. No wasted sentences, though the example could be more illustrative.

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 node-adding tool with 3 parameters and no annotations, the description covers the basic purpose and parameters but lacks details on node placement behavior, connection defaults, and post-add actions (e.g., compile). The output schema exists but the description doesn't explain what the tool returns. The KB reference helps but is not fully self-contained.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all three parameters (blueprint_name, damage_amount, node_position) with brief explanations, but the explanations are minimal and mostly restate the parameter names. It doesn't clarify the format of node_position (e.g., [X, Y] coordinates relative to what) beyond the example, and damage_amount's units/range are unspecified. The example shows usage but not 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 clearly states the tool adds an 'Apply Point Damage' node, specifies it deals damage at a specific world location/direction, and distinguishes it from the similar 'Apply Damage' node by including hit location and direction for physics reactions. It could be slightly clearer about the exact resource (blueprint graph) but the verb 'Add' and the node name are specific.

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

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

The description explicitly compares to 'Apply Damage' and explains when this variant is preferred (when physics reactions like pushback from projectile impact are needed). It doesn't explicitly state when NOT to use it or name the sibling tool add_apply_damage_node, but the comparison provides clear context 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates the tool modifies a Blueprint graph by adding a node and notes one constraint (Modulo is integers only), but it does not mention side effects, prerequisites such as the target Blueprint existing or being loaded, whether the graph is compiled or saved, or failure behavior. The 'Power' omission from the opening list also creates ambiguity about the actual behavioral surface.

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

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

The description is front-loaded with the core action and uses bullet lists, an Args block, a KB reference, and an example in a scannable structure. It is slightly redundant: the opening parenthetical duplicates the operator list in Args, and the Ch.2 section restates operator meanings. Overall, each section serves a purpose, but trimming redundancy would tighten it.

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

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

For a 4-parameter mutation tool with no annotations, the description covers the key inputs, provides valid value sets, and includes an example; the presence of an output schema reduces the need to describe return values. However, it omits prerequisites (e.g., the Blueprint must exist) and post-conditions (e.g., whether the node needs connection or compilation), and the Power/Modulo listing discrepancy leaves a small open question. It is adequate but 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 description coverage is 0%, so the description must compensate, and it largely does. It defines blueprint_name, lists valid operator and operand_type values, and explains node_position as an optional [X, Y] graph position. It even provides a concrete example call. Minor gaps remain around node_position coordinate conventions and exact blueprint asset path formatting, but the description adds meaningful semantics beyond the bare 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 opens with a specific verb+resource, 'Add an arithmetic operator node', and enumerates the supported operators (Add, Subtract, Multiply, Divide, Modulo) and operand types. This clearly identifies the tool's function and distinguishes it from other node types, though it never names sibling tools explicitly. A minor inconsistency exists: the opening list omits 'Power' while the Args section includes it, which slightly muddies the exact supported set.

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 background ('Arithmetic operators create expressions in Blueprints') and an example call, but it does not state when to use this tool versus closely related siblings like add_math_node, add_relational_operator_node, or add_logical_operator_node. No exclusions, alternatives, or selection criteria are provided, so an agent must infer usage from the tool 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 carries the full burden of behavioral disclosure. It does not mention side effects such as blueprint mutation, compile requirements, overwrite behavior, or failure behavior if the variable already exists. The only behavioral context is that is_exposed affects visibility in the Details panel, which is more of a parameter detail.

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

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

The description is compact and front-loaded, with the core purpose stated first and additional information organized into Args, KB, and Example sections. The Args block partly duplicates the schema, but since the schema has no descriptions, it earns its place here.

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 provides enough to attempt a basic call, especially with the example and parameter list. It omits prerequisites, expected failure modes, and explicit routing among related variable-creation tools, but the presence of an output schema reduces the need to document return values.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It lists all four arguments with brief but meaningful explanations, including example element types and a concrete call example. However, element_type is left open-ended with 'etc.', so some ambiguity remains.

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

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

The description opens with a clear, specific verb-resource pair: 'Add an Array variable to a Blueprint.' It also defines what an Array is, and the sibling list includes add_map_variable and add_set_variable, so naming the container type helps distinguish it from those 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 about when to choose this tool over add_blueprint_variable, add_map_variable, or add_set_variable. The KB reference is a pointer to general data-structure documentation, not an explicit when-to-use or when-not-to-use instruction.

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 behavioral disclosure burden. It explains what the node does, attachment rule semantics, and that weld_simulated_bodies welds physics bodies. While it doesn't explicitly warn that adding a node mutates the Blueprint asset, the 'Blueprint to add the node to' argument makes the mutating nature reasonably clear.

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 well-organized with sections for purpose, attachment rules, args, KB reference, and example. The content is mostly necessary and useful, though the 'From Ch. 15' and KB line add minor context rather than essential invocation 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?

The description is complete enough for an agent to invoke the tool: all six parameters are explained, enum values are provided, the node's runtime behavior is clear, and an example call is included. The presence of an output schema covers return values, so no further output documentation 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?

Schema description coverage is 0%, and the description compensates fully by documenting every parameter: blueprint_name, location_rule, rotation_rule, scale_rule, weld_simulated_bodies, and node_position. It also gives the exact enum-style choices for the rule parameters ('KeepRelative', 'KeepWorld', 'SnapToTarget') with their behavioral meanings.

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 an AttachActorToComponent node') and a specific resource ('Blueprint to add the node to'). It further clarifies the node's runtime purpose ('Attaches an actor to a component at runtime') with concrete examples ('weapon pickup, mounting to vehicles'), which distinguishes it from other add-node 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 gives clear usage context: it is 'Used for dynamic attachment' with examples. It does not explicitly list alternatives or when not to use it, but the examples and node scope make the intended use clear enough for an agent to select it correctly among many sibling add-node 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 provided, so the description carries the full burden of behavioral disclosure. It only says 'Add' without explaining side effects such as whether the AnimGraph is mutated and saved, whether the referenced Blend Space asset must already exist, what happens on failure, or whether the operation requires compilation. The KB reference hints at more context but does not itself disclose these behaviors.

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

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

The description is compact and front-loaded with the core action. The explanatory sentence about Blend Spaces earns its place by helping with usage, and the Args block plus example are directly useful. There is no fluff or redundant repetition; every sentence contributes.

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 an output schema exists, return-value documentation is not required. The description covers the key inputs and gives a concrete example, but it omits practical prerequisites such as whether the Animation Blueprint must already exist, what coordinate format node_position expects, and how the node integrates with adjacent AnimGraph nodes. The KB link helps but the description alone is not fully self-sufficient.

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

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

The schema has 0% description coverage, so the description must compensate. It provides per-argument comments like 'Animation Blueprint name', 'Blend Space asset path', and 'Optional graph position', which add some meaning beyond bare titles. However, node_position lacks any format or coordinate system, and anim_blueprint_name is nearly a restatement of the schema title. The example clarifies the expected path style, but the parameter semantics remain thin.

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

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

The first sentence states a specific verb, resource, and target: 'Add a Blend Space node to an Animation Blueprint's AnimGraph.' This is unambiguous and clearly distinguishes the tool from other node-adding siblings like add_sequence_player_node or add_state_machine, which have different purposes. The description leaves no doubt about what the tool does.

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

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

The description explains when this tool is relevant: 'Blend Spaces blend animations based on one or two float parameters (e.g., Speed and Direction for a locomotion blend space).' This gives clear context for when to use a Blend Space node. However, it does not explicitly mention when not to use it or name alternatives, so it stops short of full routing guidance.

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

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

With no annotations provided, the description carries the full transparency burden. It does disclose the node kind, its pins, and the return dict, but it omits side effects such as whether the asset is modified in memory only, whether compile/save is required, and what happens on invalid graph or asset names. It does not contradict the annotations because none exist.

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

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

The description is front-loaded with the core action and organized into compact labeled sections (Args, Returns, KB, Example). Each sentence adds useful invocation detail; there is 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?

For a three-parameter node-creation tool with no annotations and no schema-level descriptions, the description is nearly self-contained: it covers the required parameter, defaults, optional position, return keys, and a concrete example. It could be more complete by naming when to use this instead of add_branch_node, but nothing essential to making the call is missing.

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

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

The schema has 0% description coverage, but the description's Args section meaningfully documents all three parameters: blueprint_name, graph_name with its default, and node_position as an optional [X, Y] canvas coordinate. It is not a 5 because blueprint_name is described as 'Asset name' while the example passes a full /Game/ path, leaving slight ambiguity.

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

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

The first sentence clearly identifies the action ('Add') and resource ('Branch (If/Then/Else) node to a Blueprint graph'), and the next sentence pins down the standard UE5 node semantics. It loses the fifth point because the sibling list also contains add_branch_node, and this description never distinguishes this tool from that likely overlapping alternative.

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

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

There is no explicit 'when to use' or 'when not to use' guidance, and no alternative tools are named. The default graph_name='EventGraph' implies the intended context, but the agent is left to choose among dozens of add_*_node siblings 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?

No annotations are provided, so the description must disclose behavior itself. It reveals the underlying node class (K2Node_DynamicCast) and the exact return structure including pins, but it doesn't mention side effects such as modifying the blueprint asset, error conditions, or prerequisites beyond the parameters.

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

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

The description is compact and front-loaded with the purpose. It uses clear sections (Args, Returns, KB, Example) without redundancy, though the Returns section is slightly verbose.

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

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

The description covers the parameters, return values, and includes a KB reference and example, which is sufficient to call the tool. It lacks guidance on when to use it versus similar node-adding tools and does not mention whether the graph is modified immediately.

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

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

Schema description coverage is 0%, so the description must fully explain the parameters. It does so for all four: blueprint_name, cast_target_class (with examples of short names and full paths), graph_name (default), and node_position (optional [X,Y] format). This exceeds what the schema offers.

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

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

The description states a clear action: add a specific node type (K2Node_DynamicCast) to a Blueprint graph. It names the resource precisely and provides an example, though it doesn't explicitly differentiate from the sibling tool add_cast_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?

Usage is implied by the action and parameters but no explicit guidance is given about when to choose this over alternatives like add_cast_node or other blueprint node tools. There are no exclusions or conditional recommendations.

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

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

Annotations are absent, so the description carries the full burden. It discloses that the operation adds a non-logic comment box, explains its visual purpose, documents defaults, and states the return dict shape. It does not cover failure modes or whether the target graph must already exist, so not a 5.

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

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

Well-structured with an action summary, short rationale, Args list, Returns list, KB pointer, and example. Each section earns its place and no redundant prose is present.

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 7 parameters and no annotations, the description provides enough for an agent to call the tool correctly: all parameters are explained, defaults are shown, the return shape is listed, and a concrete example path is included.

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

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

Schema description coverage is 0%, but the Args section compensates fully: every parameter gets a plain-language meaning, default, unit, or format, including color ranges and the [X, Y] node position convention.

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

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

States a specific verb ('Add') and resource ('comment box (UEdGraphNode_Comment) to a Blueprint graph'). Clarifies that comment boxes are visual organizers and do not affect logic, which differentiates this from the many other add_blueprint_node-style 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?

Gives clear context: use this when you need a visual comment/grouping box in a Blueprint graph. Explicitly notes that it does not affect logic, implying it should not be used for behavior changes. Does not name alternative tools explicitly, so it misses the top score.

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 explains the node's runtime behavior, lists all pins, and describes the return structure, giving the agent a clear picture of what the operation produces. It could go further by noting side effects like graph mutation or prerequisites, but the core behavior is well covered.

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

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

The description is well-structured and front-loaded with the primary action, followed by concise behavior, pin, parameter, return, and example sections. Every sentence adds value without unnecessary verbosity.

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

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

The description covers the node's behavior, pins, parameters, return values, and includes an example call, which is strong for a 3-parameter tool with an output schema. Minor gaps remain around prerequisites such as the blueprint already existing or graph resolution semantics, but the definition is largely 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 0%, yet the description compensates fully by documenting every parameter: blueprint_name, graph_name, and node_position, including defaults and types. This provides meaning far beyond the input schema.

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

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

The description clearly states the verb and resource: 'Add a DoOnce macro node to a Blueprint graph.' It explains what the node does, which helps the agent understand the tool's purpose. However, it does not explicitly differentiate this from the very similar sibling tool add_do_once_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 behavior description, 'only fires the Completed output once until Reset is triggered,' implies the tool should be used when a one-shot execution pattern is needed. No explicit when-not-to-use guidance or alternatives are provided, so usage context 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 present, the description carries the behavioral burden. It discloses the exposed exec and data pins, the accepted action_asset formats, the returned fields, and the fact that wiring is a separate follow-up step. It does not discuss error conditions or side effects like graph modification or compilation, but it provides substantially more behavioral context than a typical tool description.

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

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

The description is longer than average but every section earns its place: purpose, usage context, asset format examples, post-add workflow, args, returns, KB reference, and a concrete example. It is front-loaded with the core statement and uses structured sections rather than prose bloat.

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 4-parameter mutation tool with no annotations, the description is complete enough for an agent to call it correctly. It covers all parameters, explains return values, gives an example, links to KB documentation, and tells the agent what to do after adding the node. Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does thoroughly. The Args section explains blueprint_name, action_asset (with two accepted formats and examples), graph_name (with default 'EventGraph'), and node_position as an optional [X, Y] canvas position. This adds real meaning beyond the bare schema types.

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

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

The description opens with a specific verb+resource: 'Add an Enhanced Input Action event node (K2Node_EnhancedInputAction) to a Blueprint graph, wired to the specified UInputAction asset.' This clearly identifies what the tool does and differentiates it from the many sibling add_blueprint_*_node tools by naming the exact node type and the Enhanced Input system.

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

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

The description gives clear context: 'This is the correct node type for projects using Unreal Engine's Enhanced Input system (which replaces the legacy Input Actions in UE5).' It also provides a follow-up workflow (use connect_blueprint_nodes and get_blueprint_nodes). It does not explicitly name a sibling alternative like add_blueprint_input_action_node, but the Enhanced Input qualification strongly implies when to choose 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose the return dict (node_id/node_name), the graph_name default, node_position optionality, and an example asset path. However, it says nothing about failure modes (invalid event name, missing blueprint, duplicate event) or whether the event name is validated against the listed set, which matters for a graph-mutating 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 front-loaded with purpose, then organized into clear sections (event names, args, returns, KB ref, example). The common-event list and example are genuinely useful, not filler. Slightly long but each block 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 4-param tool whose output schema (node_id/node_name dict) is described inline, the definition covers purpose, parameters, return format, and usage example, plus a KB pointer. Missing pieces are error/edge-case behavior and whether the target graph must already exist, but nothing essential for a basic call is absent.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: all four parameters are enumerated with brief meanings, and the example clarifies that blueprint_name expects a full /Game/... path. The main weakness is terseness (e.g., 'Asset name' vs path) and no guidance on node_position coordinate conventions, but overall it compensates well for the empty 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-resource pair ('Add an event node to a Blueprint graph') and enriches it with a list of common event names and a concrete example with a full asset path. However, it does not explicitly differentiate itself from the many sibling tools that also add events (add_custom_event, add_overlap_event, add_hit_event, add_event_dispatcher), so an agent must infer the boundary.

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

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

The common event-name list and graph_name default imply which scenarios apply, but there is no explicit when/when-not guidance and no mention of alternatives. With a large cluster of add_*_event siblings, the lack of routing rules (e.g., 'for custom events use add_custom_event instead') leaves 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 burden. It discloses the alternating behavior and the pins, but does not mention side effects on the graph, whether the operation is additive, or potential errors if the blueprint or graph doesn't exist. It is a mutating operation with no stated preconditions.

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 relatively concise, with a summary, pin list, parameter list, returns, and an example. It is front-loaded with the primary purpose and alternation behavior. The example is useful, though the KB reference may be extraneous for the core task.

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

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

The tool has an output schema (not shown in text, but indicated), so return values are covered elsewhere. The description includes enough information for an agent to understand what the tool does, the parameters, and an example. However, it lacks details on error handling or prerequisites like blueprint existence.

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

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

Schema description coverage is 0%, but the description briefly explains the purpose of each parameter (blueprint_name as asset name, graph_name as graph to add to, node_position as canvas position) and provides an example for blueprint_name. This adds meaning beyond the bare 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 adds a FlipFlop macro node to a Blueprint graph, describing its alternating behavior between A and B exec outputs on each trigger and listing the pins. It distinguishes from other add_*_node tools by its explicit function and pin list.

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

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

The description explains when to use the tool (to add a FlipFlop node) and provides a concrete example with a blueprint_name. It does not explicitly mention when not to use it or alternatives, but the context of adding a specific macro node is clear given the sibling 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?

With no annotations, the description carries the full behavioral burden. It does disclose genuinely useful structural behavior: the six pins with their types (wildcard array, exec, int) and the returned dict keys. But as a mutation tool it never states what adding the node does to the graph (node count growth, exec-chain placement, whether a compile is needed afterward), and blueprint_name is labeled 'Asset name' while the example shows a full asset path — an unaddressed inconsistency.

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 layout is exemplary: one-sentence summary up front, then compact labeled sections for pins, args, returns, KB link, and a runnable example. Every line earns its place and the structure is scannable for an LLM. No filler or repetition of the schema.

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

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

The mechanics are complete — output schema exists and the description even pre-states the return keys, all params are documented, and a KB pointer plus example anchor usage. What's missing is the selection context: in a namespace with ~130 sibling add-node tools including a near-duplicate, the description never explains why this tool exists or when to pick it over add_for_each_loop_node. That gap is material for correct invocation.

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

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

Schema description coverage is 0%, so the description fully compensates by documenting all three parameters: blueprint_name (with the example clarifying path format), graph_name (default 'EventGraph'), and node_position (optional [X, Y] format). The only blemish is the 'Asset name' vs full asset path discrepancy between the arg line and the example.

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+resource: 'Add a ForEachLoop macro node to a Blueprint graph.' The pin listing reinforces what the node contains, and the 'macro' qualifier hints at the distinction from a plain loop node. However, it doesn't explicitly differentiate from near-twin siblings like add_for_each_loop_node or add_blueprint_for_loop_with_break_node, so it stops 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?

There is no when-to-use guidance, no exclusions, and no mention of alternative loop-node tools despite a crowded sibling family (add_for_each_loop_node, add_while_loop_node, add_blueprint_for_loop_node, add_blueprint_for_loop_with_break_node). An agent picking between these near-identical names gets zero steer from the description. The example and KB reference help operationally but not selection-wise.

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 behavioral burden and does a solid job: it says the tool adds a node, lists every pin and its type, documents argument defaults, and gives the returned dictionary keys. It does not mention side effects such as whether the Blueprint is saved or compiled, but the core add-node behavior is clearly 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 front-loaded with a one-sentence summary, then organized into labeled Pins, Args, Returns, KB, and Example sections. Every line adds useful information, and the formatting makes it easy for an agent to scan 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 5-parameter tool with zero schema descriptions and no annotations, the description covers the call contract well: argument semantics, defaults, return shape, a KB pointer, and a concrete example. It could be slightly more complete by explaining graph_name path conventions or node_position coordinate units, but the essential calling context is present.

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

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

Schema description coverage is 0%, yet the description documents all five parameters with meaning and defaults: blueprint_name as an asset name, graph_name defaulting to 'EventGraph', first/last index defaults, and node_position as an optional [X, Y] canvas position. The example includes a full Blueprint path, leaving no parameter meaning to inference.

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

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

The first sentence states an exact action and target: 'Add a standard ForLoop macro node to a Blueprint graph.' The pin listing (Exec, First Index, Last Index, Loop Body, Index, Completed) identifies the precise Unreal Blueprint node and helps distinguish it from sibling loop-node tools such as the ForEachLoop variant.

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 prefer this tool over the many sibling add_*_node tools, nor does it name alternatives such as add_blueprint_for_each_loop_node. The intended use is implied by the node name and the integer First/Last Index pins, so an agent must infer the selection context rather than being told it directly.

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

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

The description discloses important behavioral traits: the duplicate guard (allow_duplicates=False returns existing node within 32 units), the handling of params values (strings, numbers, booleans), and the return values including was_existing. It also explains the target parameter's fallback behavior (searching the Blueprint's own class hierarchy). No annotations are provided, so the description carries the full burden, and it does so well.

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 well-structured with clear sections for function_name, target, duplicate guard, params, Args, Returns, and an example. It's longer than average but every section adds value. The front-loading is good: the core purpose is stated first, followed by the most important parameter details. The example at the end is helpful. Slightly verbose but justified by the complexity.

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

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

Given the tool's complexity (7 params, nested objects, no annotations, 0% schema coverage), the description is quite complete. It covers all parameters, return values, and edge cases (duplicate guard). The KB reference provides additional context. It could be more explicit about when to use this vs. other node-adders, but for the tool's own operation, it's 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?

Schema description coverage is 0%, so the description must compensate. It does: it explains function_name formats (short name vs full UE path), target ownership, params as pin_name->default_value dict, node_position as [X,Y], and allow_duplicates semantics. It also documents the return dict. The only minor gap is that graph_name default 'EventGraph' is mentioned in Args but not elaborated, and node_position format is only briefly shown.

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: 'Add a function-call node to a Blueprint graph.' It specifies the resource (Blueprint graph), the action (add a function-call node), and provides detailed context on how to specify the function (short name or full UE path). This distinguishes it from sibling tools like add_blueprint_event_node or add_blueprint_variable_get_node, which add different node types.

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

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

The description provides clear guidance on when to use this tool, including how to specify function_name and target, and explains the duplicate guard behavior. It doesn't explicitly state when NOT to use it or name alternative tools for different node types, but the detailed parameter guidance and the KB reference give strong usage context. The sibling list shows many node-adders, but the description doesn't explicitly differentiate from them.

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 does communicate that the tool creates or updates and returns a dict, which implies a mutating operation. However, it does not disclose whether updating an existing function replaces pins, whether it requires the Blueprint asset to already exist, or whether compilation is needed afterward.

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 well-structured and efficient: a one-sentence summary, a usage guidance line, compact Args list, Returns line, KB pointer, and a complete example. Every section earns its place and is front-loaded appropriately.

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?

All parameters, the return shape, and a worked example are provided, and the KB reference adds depth. It is nearly complete, but it omits edge-case behavior around updating an existing function graph and any prerequisites on the Blueprint asset itself.

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 0% description coverage and its item schemas are generic objects, but the description fully compensates. It explains blueprint_name, function_name, inputs, outputs, and is_pure with examples and notes the optional sub_type for object/class-backed pins.

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-resource pair: 'Create or update a Blueprint function graph with typed signature pins.' It further distinguishes itself from siblings by saying 'not a call node in an existing graph,' making it clear this is for authoring reusable function graphs rather than adding function-call nodes.

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

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

The description explicitly states when to use it: 'Use this when an agent needs a reusable gameplay function, not a call node in an existing graph.' This gives a clear when-to-use and when-not-to-use signal, though it does not name the exact alternative sibling tool to use for call-node insertion.

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 behavioral burden. It clearly communicates that this is a mutating add operation, describes the Gate's runtime behavior and pin layout, and lists the return keys. It does not disclose preconditions such as whether the Blueprint or graph must already exist, or whether the asset needs saving afterward.

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 well-structured with clear sections for behavior, args, returns, knowledge base reference, and an example. The one-line purpose is front-loaded, and every section adds operational value with no 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 4-parameter tool with an output schema and no annotations, the description is largely complete: action, parameter semantics, defaults, return shape, and an example are all covered. The remaining gaps are the lack of sibling-routing guidance and explicit preconditions about the target Blueprint and graph.

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

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

Schema description coverage is 0%, so the description must explain each parameter. It does so for all four: blueprint_name as the asset name, graph_name with its default, start_closed with its meaning, and node_position as an optional [X, Y] canvas position. It stops short of 5 by not clarifying valid graph names or position units.

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

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

The opening line states a specific verb and resource: 'Add a Gate macro node to a Blueprint graph.' The Gate execution semantics and pin list further pin down exactly what kind of node this is, distinguishing it from generic add_macro_node or add_gate_node 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 Gate behavior ('passes execution through its Exit pin only when open') implies when this tool is useful, and the example shows a concrete call. However, it never explicitly says when to prefer this over related siblings like add_gate_node or add_macro_node, nor does it state when not to use it.

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

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

With no annotations, the description carries the full burden. It discloses meaningful behavior: validation against the SimpleConstructionScript, searching inherited C++ component properties, and returning the actual 'component_class'. However, it does not explicitly state the side effect of modifying the blueprint graph or error behavior when a component is not found, though 'if found' on the return value hints at partial failure.

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 well-structured into purpose, differentiation, usage timing, args, returns, KB reference, and example. Each section earns its place and there is no filler. The main purpose is front-loaded, making it easy for an agent to scan.

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

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

For a 4-parameter, 2-required node creation tool with no annotations, the description covers the action, when to use it, all parameters, return keys, a KB reference, and a concrete example. The 'if found' qualifier on component_class also communicates partial-failure behavior, making the description sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate—and it does. Every parameter is explained with context: blueprint_name as asset name, component_name with concrete examples ('Mesh', 'CapsuleComponent', 'CharacterMovement'), graph_name with default, and node_position as optional canvas position. It also documents the response keys, going beyond the bare schema.

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

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

States a specific verb and resource: 'Add a node that gets a reference to one of the Blueprint's SCS components.' It also distinguishes itself from the sibling add_blueprint_get_self_component_reference by explicitly contrasting its validation behavior with the sibling's blind trust of component names, so an agent can tell them apart without opening schemas.

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

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

Gives an explicit when-to-use condition ('Use this when you know a component was added in the Blueprint editor') and names the alternative tool while explaining the key difference (validation vs. blind trust). This is strong routing guidance for two closely related 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 provided, so the description carries the behavioral disclosure burden. It does disclose the core side effect (adding a node), the default graph, and the return dictionary keys, but it omits edge-case behavior such as missing components/graphs, whether the asset is modified immediately, and how node_position defaults are handled.

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 well-structured with purpose, equivalent action, Args, Returns, KB reference, and an example. Every section adds value, and the main action is front-loaded before the parameter 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 4-parameter node-adding tool with no annotations and an output schema, the description covers the required invocations well: all parameters are explained, defaults are noted, and the return shape is given. It could be more complete by noting prerequisites (e.g., the component must already exist in the Blueprint) and by pointing to sibling tools for adjacent operations.

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 0% description coverage, but the description fully compensates by explaining each parameter: blueprint_name as asset name (with full-path example), component_name as component variable name, graph_name with default, and node_position as optional [X, Y] canvas position. The example also disambiguates the expected path format.

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 node that gets a reference to one of the Blueprint's own components') and an analogy ('Equivalent to dragging a component from the Components panel into the graph'). This clearly differentiates it from related siblings like add_blueprint_self_reference or add_blueprint_get_component_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 gives no explicit guidance on when to use this tool versus sibling tools such as add_blueprint_get_component_node or add_blueprint_self_reference. The 'Equivalent to dragging...' analogy provides context for what it does, but not a decision rule for choosing it over alternatives.

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

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

With no annotations, the description carries the behavioral burden. It clearly states this is a mutation, specifies the return shape ('Dict with node_id'), and provides a KB pointer and example. However, it does not disclose failure behavior for invalid blueprint/graph/action names, whether compilation is triggered, or other graph side effects, leaving some behavioral gaps.

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

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

Front-loaded with the core purpose and the key non-Enhanced Input distinction, followed by compact Args, Returns, KB, and Example sections. Every line earns its place; there is no filler or redundant restatement.

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 4-parameter tool with an output schema, this description is complete: required params, optional position, default graph, return type, a KB reference, and a concrete example. The only omitted information is edge-case error behavior, which is less critical for selecting and invoking the tool correctly.

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

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

Schema description coverage is 0%, but the Args block fully compensates by documenting every parameter, including defaults ('graph_name' default 'EventGraph'), optionality ('node_position'), and the expected '[X, Y]' format. The example further demonstrates the call signature and asset-path format.

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

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

States a specific verb ('Add') and resource ('legacy Input Action event node'), and immediately disambiguates with '(non-Enhanced Input)'. This clearly distinguishes it from the sibling add_blueprint_enhanced_input_action_node and the find_blueprint_nodes workflow.

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

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

Explicitly directs the agent away from this tool for Enhanced Input actions that already exist, telling it to use find_blueprint_nodes with node_type='input_action' instead. It also labels the tool as legacy/non-Enhanced Input, implying the exclusion. It could be slightly more explicit about the sibling add_blueprint_enhanced_input_action_node for creating new Enhanced Input nodes, so it stops short of a 5.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It clearly states the operation ('add a node') and the return value, but it does not mention side effects like asset mutation persistence, the need to save/compile afterward, or prerequisites such as the blueprint existing. This is a meaningful 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 tightly organized: purpose sentence, args list, return type, KB link, and example. Every line earns its place, and the most important action is front-loaded.

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

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

For a low-complexity tool with an output schema, the description covers parameters, return, and includes an example plus KB reference. Yet it omits usage context and behavioral caveats (persistence, prerequisites), which are needed because there are no annotations and sibling differentiation is absent.

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

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

Schema description coverage is 0%, so the description must compensate. It gives one-line semantic explanations for all three parameters, including defaults and format ('Optional [X, Y] canvas position'). However, 'Asset name' for blueprint_name is terse and ambiguous until seen in the example, so the compensation is adequate but not rich.

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 names a concrete resource ('Get a reference to self' node) with a clarifying parenthetical about what the node returns. It does not explicitly mention sibling tools, so it is clear but not strongly differentiated from the many add_blueprint_* sibling tools.

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

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

No guidance is given about when to use this tool versus alternatives such as add_blueprint_get_self_component_reference or add_get_owner_node. The description simply states what it does, leaving the selection decision to the agent without contextual hints.

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 behavioral burden. It discloses that the node executes outputs in order, that outputs can be added manually, and what the return dict contains, but it does not address side effects such as whether the Blueprint is modified/saved before a compile or any prerequisites for the target graph.

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

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

The description is front-loaded with the action, then uses compact labeled sections for behavior, arguments, return value, knowledge-base pointer, and a concrete example. There is no wasted prose; the explanatory lines about Sequence node behavior earn their place.

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

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

For a simple node-adding operation, the description covers the action, parameters, return shape, and an example, plus a KB reference for background. It is missing only a note about selecting among similar add_*_node tools and any post-add workflow (e.g., compiling/saving the Blueprint), which keeps it from being fully complete.

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

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

Schema description coverage is 0%, and the Args section fully compensates: it defines blueprint_name as the asset name, gives the graph_name default ('EventGraph'), and specifies node_position as an optional canvas [X, Y]. Every parameter is explained beyond the raw type/default in 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 opens with a specific verb and resource: 'Add a Sequence macro node to a Blueprint graph.' It clearly identifies the target and node type, but it never distinguishes itself from the similar sibling add_sequence_node or the broader add_blueprint_*_node family, so it stops 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?

The scope is implied through the explanation that a Sequence node 'executes multiple outputs in order,' which signals when an agent would want this node. However, there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives, so the agent must infer routing from the name and explanation.

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 disclosure burden. It usefully lists the pins, the return dict keys, a KB reference, and an example. However, the 'Spawns a new actor' phrasing muddles the tool's actual behavior (node placement vs. runtime spawning), and no failure modes or preconditions 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 well-structured with Args, Returns, KB, and Example sections, and the purpose is front-loaded. It is slightly longer than necessary — the pin enumeration and the 'Spawns a new actor' line add some redundancy — but every section earns its place and the formatting aids scanning.

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

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

It has an output schema, so return-value coverage is handled, and the example plus KB link help. But given the extensive sibling overlap, the missing sibling differentiation is a real completeness gap — an agent needs to know when to pick this over add_spawn_actor_from_class_node or add_spawn_actor_node. The pin list and default guidance are otherwise solid.

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

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

Schema description coverage is 0%, so the description must compensate — and it does. All four parameters are explained: blueprint_name as asset name, actor_class as short class name with an unwired default option, graph_name with its default, and node_position as [X, Y] canvas coordinates. This meaningfully exceeds what the bare schema 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 states a clear verb+resource: 'Add a SpawnActorFromClass node... to a Blueprint graph' and names the exact Unreal node type (K2Node_SpawnActorFromClass). However, it does not differentiate from the near-duplicate sibling add_spawn_actor_from_class_node, and the 'Spawns a new actor' line describes the node's runtime behavior rather than the tool's action, introducing mild ambiguity about whether the tool spawns an actor or places a 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?

There is no when-to-use guidance, no alternative routing, and no exclusions. With a large sibling family including add_spawn_actor_node, add_spawn_actor_from_class_node, spawn_actor, and spawn_blueprint_actor, an agent has no way to tell this tool apart from add_spawn_actor_from_class_node, which appears to do the same thing.

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 behavioral disclosure burden. It clearly states the graph mutation and node behavior, and lists return keys, which is useful. It does not disclose side effects such as duplication behavior, asset save/compile implications, or failure modes when adding to an invalid graph.

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 structure is efficient: purpose, behavior, args, returns, KB reference, and example all in a compact format. There is slight redundancy between the opening sentence and the routing-behavior sentence, but no filler or irrelevant 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 3-parameter node-creation tool with an output schema, the description covers inputs, defaults, return fields, and a runnable example. The main gaps are the lack of disambiguation from add_switch_on_int_node and missing side-effect/safety caveats, but it is otherwise complete enough for an agent to call correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains all three parameters meaningfully: blueprint asset name, target graph with default, and optional [X, Y] canvas position. It also provides an example asset path, though it does not fully specify path-vs-name requirements.

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, resource, and target: 'Add a Switch on Int node (K2Node_SwitchInteger) to a Blueprint graph.' It also explains the node's routing behavior. However, it does not explicitly differentiate itself from the very similar sibling tool add_switch_on_int_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 usage context is implied: use this when you need a Switch on Int node in a Blueprint graph, supported by a default graph name and example. It does not state when not to use it, nor does it mention alternatives among the many blueprint node-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 discloses important behavioral details beyond the schema: it explains the effect of is_exposed (BlueprintVisible + Edit), states that default_value is stored in both the FBPVariableDescription and the Blueprint CDO, and documents the return value. It also lists supported variable_type values, which is critical runtime behavior. No annotations are provided, so the description carries the full burden, and it does so well.

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 well-structured with clear sections: a one-line summary, supported types, args, returns, KB reference, and example. It's longer than average but every section earns its place given the 0% schema coverage. The most critical information (supported types and parameter semantics) is front-loaded, and the example at the end is a useful capstone.

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 5-parameter tool with 0% schema coverage and no annotations, the description is quite complete. It covers all parameters, valid values, return format, and provides a KB reference and example. It doesn't mention error conditions or side effects (e.g., whether the blueprint needs to be compiled afterward), but the core information needed to call the tool correctly is present. The output schema exists, so return values are partially covered by structured data.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains blueprint_name, variable_name, variable_type (with a full list of valid values), is_exposed (with its BlueprintVisible+Edit meaning), and default_value (with format examples and storage semantics). The only minor gap is that it doesn't explain the exact format for Object/<FullClassPath> beyond one example, but the provided example is sufficient.

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 member variable to a Blueprint') with a specific verb and resource. It distinguishes itself from siblings like add_blueprint_variable_get_node and add_blueprint_variable_set_node by focusing on the variable declaration itself, not graph nodes. The supported variable_type list and example further clarify the tool's purpose.

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

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

The description provides a clear context for when to use this tool (adding a member variable to a Blueprint) and includes a knowledge base reference for deeper understanding. It doesn't explicitly state when NOT to use it or name alternative tools, but the context is clear enough for an agent to select it over the many node-adding siblings. The example invocation also serves as a usage pattern.

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 behavioral disclosure. It mentions that the tool adds a node (implying mutation) and returns a dict with specific fields. It also explains target_class usage for cast pawn scenarios. However, it does not explicitly state prerequisites (e.g., blueprint must exist) or potential side effects beyond the addition, and it does not disclose any limitations.

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 well-structured with clear sections (Args, Returns, KB, Example). It is concise yet complete, front-loading the core purpose and then detailing parameters. The example provides a practical usage pattern. Every sentence adds value, and the format is easy to scan.

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

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

The description covers all parameters, provides an example, and references a KB document. It mentions the return structure (node_id, node_name, pins). However, it does not explicitly state that the blueprint must already exist or that the graph will be modified, which are key for an agent deciding to use this tool. Given the tool's complexity and the presence of an output schema, it is mostly complete but missing a few contextual prerequisites.

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 explains all five parameters in the Args section, including defaults and optionality. It adds meaning beyond the schema (e.g., graph_name default 'EventGraph', node_position optional, target_class usage for cast pawns). With 0% schema description coverage, the description fully compensates by clarifying each parameter's purpose and default behavior.

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 Get Variable node for a Blueprint variable.' It specifies the resource (Blueprint variable) and the operation (add node). The Args section further clarifies each parameter. While there are many sibling add_blueprint_* tools, this one is specifically for variable get nodes, and the description 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 provides some usage context (e.g., target_class for cast pawn, default graph_name) but does not explicitly distinguish when to use this tool over similar siblings like add_get_variable_node or add_set_variable_node. It lacks explicit when-to-use or when-not-to-use guidance, leaving the agent to infer the right scenario.

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. It clearly implies mutation ('Add') and discloses the return dict, but it does not warn about preconditions (e.g., whether the blueprint must be compiled/loaded), save-side effects, or potential failures if the variable doesn't exist. This is acceptable but not exhaustive.

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 docstring is well organized with Args, Returns, KB, and Example sections. Every section adds value—especially the example and KB pointer—and there is no redundant 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?

Covers all parameters, provides defaults, a usage example, and a knowledge base reference. It does not detail the exact structure of the returned dict beyond keys, but that is minimal for an agent operating in this domain. Overall, it adequately enables correct invocation.

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

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

The schema has 0% description coverage, and the description compensates by explaining each parameter in the Args section, including defaults and optionality. While target_class's 'same resolution as native bridge' is cryptic, the rest clarify the schema meaning 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?

States the specific operation ('Add a 'Set Variable' node') and the target resource ('for a Blueprint variable'). The verb and object are unambiguous, and the node type is clearly distinguished from sibling tools like add_blueprint_variable_get_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?

No explicit 'when to use' or when-not-to-use guidance. The example shows a call but does not contrast this with similar sibling tools like add_set_variable_node or add_blueprint_variable_get_node. The KB link is a reference but not usage guidance.

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

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

No annotations are provided, so the description must carry the disclosure burden. It clearly states the tool 'Add[s]' a node and describes the trace behavior, which is good, but it does not mention side effects such as graph mutation/compilation needs, failure cases, or valid draw_debug values. Given the mutation and zero annotations, this is a partial disclosure.

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

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

The description is organized and front-loaded with the node type, then follows with a short technical line, an arg list, a KB pointer, and a minimal example. Every section earns its place, though the arg list and example make it longer than the terse ideal.

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 5-parameter mutation tool with no annotations, the description covers the action, all parameters, and an example, and an output schema exists so return values can be assumed. However, it does not say which Blueprint graph receives the node or enumerate draw_debug options, leaving some ambiguity for correct invocation.

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

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

Schema description coverage is 0%, but the Args block documents all five parameters, including units for half_size, the allowed trace_channel values, and node_position optionality. The only weakness is draw_debug, which is merely called 'Debug visualization type' without enumerating valid values.

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

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

The opening line names the exact action ('Add a ... node') and resource, and the phrase 'box-shaped sweep trace' pinpoints the geometry among sibling trace tools. It is immediately clear what the tool does and how it differs from line/sphere/capsule trace adders.

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 explicit when-to-use guidance or comparison to alternatives such as add_line_trace_by_channel_node or add_sphere_trace_by_channel_node. The 'box-shaped' phrasing implies the shape choice, and the KB link could supply context, but the decision rule is left to the agent.

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 disclose key behavior: the node takes a boolean condition and routes to True/False outputs, and returns a Dict with node_id and pins. It also notes node_position is optional. However, it does not mention that this modifies the blueprint asset (a mutation), any prerequisites like the blueprint being loaded or saved, or potential side effects. It provides some behavioral detail but leaves significant gaps.

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 well-structured and front-loaded: a clear summary sentence, then behavioral details, Args, Returns, a KB pointer, and an example. Every section adds value without redundancy. It is concise yet complete for the core information, making it easy to scan.

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

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

The tool has an output schema (not shown but present), and the description explains the return format (Dict with node_id and pins). It includes a KB reference and a concrete example. For a node-adding tool, this covers the essentials. Minor gaps include not stating whether the blueprint must be loaded or if the operation persists, but these are inferable. Overall, it is complete enough for an agent to call correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does: the Args section defines blueprint_name as 'Blueprint name' and node_position as 'Optional [X, Y] graph position'. An example clarifies that blueprint_name is an asset path (e.g., '/Game/MCP_Test/BP_Example'). This adds meaning beyond the schema's bare titles and is sufficient for an agent to understand both parameters.

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

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

The description clearly states the tool's purpose: 'Add a Branch (if/else) node to a Blueprint.' It specifies the verb (Add), resource (Branch node), and target (Blueprint), and explains the node's behavior (routes execution to True/False based on a boolean condition). This is specific and distinguishes it from generic node-adders like add_blueprint_function_node or add_math_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?

No guidance is provided on when to use this tool versus alternatives. The sibling list includes add_blueprint_branch_node and other node-adders, but the description does not reference any alternative or mention when this specific tool is preferred. The only context is the KB reference, which does not address tool 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 carries the behavioral disclosure burden. It does transparently describe the operation, the decomposed Hit Result fields, and the accepted arguments, but it does not disclose potential graph mutation side effects, failure modes, or whether compilation/saving is required. 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 well-structured and front-loaded: a clear purpose sentence, a compact field list, an arguments section, a knowledge-base pointer, and an example. Every section serves a purpose and there is no redundant 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 relatively simple node-adding tool with one required parameter, the description covers the operation, parameter semantics, node output fields, and provides an example. An output schema exists, so return values need not be described in prose; missing usage alternatives and edge cases are the main gaps.

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

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

The schema provides no descriptions (0% coverage), so the description must compensate. It adds meaning by documenting blueprint_name as a Blueprint name and node_position as an optional [X, Y] graph position, plus a concrete example. It could clarify coordinate specifics or placement behavior, but the provided semantics are genuinely useful.

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 Break Hit Result node') and the resource/purpose ('decomposes Hit Result structure'), so an agent understands what the tool does. It does not explicitly differentiate against sibling node-adding tools like add_break_struct_node, but the specific node type 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?

There is no explicit guidance on when to use this tool versus alternatives, no when-not-to-use conditions, and no prerequisites. The phrase 'decomposes Hit Result structure' and the Ch.14 context only imply a general use case; no exclusions or alternative tools are mentioned.

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 full burden of behavioral disclosure. It states the tool 'Adds' a node and explains the node's internal behavior (exposing member variables), but does not disclose side effects like whether the blueprint is modified, whether compilation is triggered, or prerequisites such as the struct type existing. The example uses an undefined 'Example' struct, which could mislead. This is adequate but not thorough 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 well-structured with a clear opening sentence, an explanatory paragraph, a bulleted Args list, a KB reference, and an example. It is moderately concise, though the Ch. 13 quote and Split Struct Pin note add some length. The essential information is front-loaded and easy to scan.

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

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

The description covers the tool's purpose, parameters, and provides an example, but lacks critical contextual details such as prerequisites (e.g., struct must exist in the project), potential failure modes, and what the tool returns (though an output schema exists). Given the simplicity of the tool and the presence of an output schema, the description is adequate but leaves some gaps that could affect correct 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 0%, so the description compensates by explaining all three parameters: blueprint_name (target blueprint), struct_type (with examples like FVector, FHitResult), and node_position ([X, Y] graph position). It clarifies meaning beyond the schema, though it does not explicitly state that node_position is optional or describe coordinate conventions. Overall it provides substantial semantic value.

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

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

The first sentence clearly states the verb 'Add' and the resource 'Break [StructType] node' with its purpose of extracting member values. It further explains the node's behavior (takes a struct, exposes all members as output pins) and gives a concrete example, making it unambiguous and distinct from sibling tools like add_make_struct_node (which constructs structs) or add_break_hit_result_node (specific to HitResult).

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 an alternative method (Split Struct Pin) but does not explicitly contrast with sibling tools such as add_make_struct_node or add_break_hit_result_node. It implies usage when reading individual fields but lacks clear when-not-to-use guidance or explicit selection criteria among the many add_* node 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, the description carries the transparency burden. It does disclose the core runtime behavior ('checks a key's value to allow or abort execution') and that it adds a decorator node. However, it omits prerequisites such as existing behavior tree/blackboard assets, whether the asset is saved/modified, and error 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 summary is front-loaded and the Args/KB/example layout is scannable. The example is poorly constructed, using 'ExampleName' for blackboard_key and duplicating it for sequence_name, which could mislead an agent. It is not bloated, but the weak example and minor 'Ch.10' reference keep it from a higher 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?

The description covers what the tool does, all parameters, a KB reference, and a call example. It omits practical setup context: whether the behavior tree and blackboard must already exist, whether the blackboard key must be defined, and how adding this decorator interacts with existing decorators. The presence of an output schema reduces the need to explain return values, but prerequisite and side-effect information is still missing.

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

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

Schema description coverage is 0%, but the Args section compensates by defining all five parameters. It provides concrete example values for blackboard_key and allowed values for observer_aborts. It doesn't explain the semantics of each observer_aborts option, but the parameter coverage is strong.

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

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

States a specific verb ('Add'), resource ('Blackboard Decorator'), and target ('Behavior Tree sequence/task node'). The description further clarifies what a Blackboard Decorator does by explaining it checks a key's value. It doesn't explicitly contrast with sibling tools like create_bt_decorator or add_bt_node, so it doesn't earn 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?

The conceptual statement 'Decorators are conditions that control whether a BT branch can execute' gives clear context for when this tool is relevant. It does not name alternative tools or provide explicit when-not-to-use guidance, but the Blackboard-specific explanation makes the intended scenario evident.

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

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

With no annotations, the description carries the full burden, and it does well by explaining parent_node_index semantics, -1 as root attachment, auto-placement when x/y are 0, and the return dict. It implies mutating behavior by saying 'add' but does not fully disclose edge cases such as invalid node types or failure 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 structured into succinct sections: usage intent, valid node types, Args, Returns, KB pointer, and example. It is moderately long but every section adds actionable information, and the most important guidance is front-loaded.

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

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

Given the complexity of 8 parameters, nested objects, and a behavior-tree-specific operation, the description covers the required parameters, optional parameters, return format, and points to knowledge_base/04_AI_SYSTEMS.md#overview for further context. Nothing critical is missing for selecting and 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?

Schema description coverage is 0%, so the description is the only source of parameter meaning. It explains all 8 parameters beyond their schema types: accepted node_type strings, parent_node_index indexing, x/y auto values, properties as string-valued dict, and decorators/services as list objects. This fully compensates for the missing schema descriptions.

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

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

The description starts with a specific verb and resource: 'Add a single node to an existing Behavior Tree graph.' It clearly distinguishes itself from build_behavior_tree by framing it as the incremental follow-up tool, and the node_type list ('Selector', 'Sequence', 'Wait', 'MoveTo', or Blueprint class path) narrows the operation precisely.

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?

'Use this for incremental edits — add one node at a time after the initial tree is built with build_behavior_tree' explicitly names the alternative tool and the condition for using this one. This gives the agent a clear routing rule without needing to compare schemas.

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

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

No annotations are provided, so the description carries the full behavioral burden. It conveys that the tool adds a button to a widget blueprint, but it does not disclose whether existing components are affected, whether the blueprint must be saved or compiled afterward, or what failure modes exist. The KB reference is not sufficient to make the behavior 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?

The description is compact and front-loaded: a clear purpose sentence, a tight Args list, one KB pointer, and one realistic example. Every section earns its place without redundant prose.

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

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

All eight parameters are semantically documented, the example clarifies the required widget_name form, and an output schema exists so return-value details are unnecessary. The main gap is the lack of explicit preconditions and behavioral effects, but the description is otherwise sufficient for invoking the tool correctly.

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

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

The schema provides only titles and array types, so the description is the only source of semantic meaning. It explains position as [X, Y] canvas coordinates, size as [Width, Height], color as [R,G,B,A] text color, and background_color as button background color. The example also demonstrates the expected asset-path format.

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

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

The first sentence states a concrete verb ('Add'), a specific resource ('Button'), and the target container ('Widget Blueprint'). The Args list further clarifies widget_name as the blueprint and button_name as the component, making it unambiguous among the many add_*_to_widget sibling 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?

There is no guidance on when to use this tool instead of add_text_block_to_widget, add_image_to_widget, or other sibling widget-construction tools. No preconditions, alternatives, or exclusions are stated; the KB link is a pointer but not an explicit usage rule.

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 does disclose the key runtime behavior: if the target doesn't implement the interface, 'nothing happens (safe call, no crash).' However, it omits that this is a graph-mutating operation, that the blueprint/interface must already exist, and what happens on failure (invalid interface name, unimplemented interface).

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 structure is well-organized with Args, KB, and Example sections, and the core purpose is front-loaded. However, the 'From Ch. 16' narrative about VRPawn and TriggerPressed spans three sentences of background that could be condensed into one, adding bulk beyond what's needed for tool selection and invocation.

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 moderate-complexity node-adding tool with no annotations and 0% schema coverage, the description covers parameters, provides a concrete example, and references knowledge base documentation. It is incomplete on prerequisites (interface already created, blueprint loaded), failure behavior, and explicit differentiation from the near-identical sibling bp_add_call_interface_function. The output schema presumably covers return values.

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

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

Schema description coverage is 0%, and the description compensates well by documenting all 5 args with meaning beyond the schema titles: blueprint_name is 'Blueprint making the call', target_variable is 'Variable or node providing the target Actor reference', and node_position is specified as '[X, Y] graph position'. The example also demonstrates the expected /Game/... path format. Slight ambiguity remains around target_variable's default-empty 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 first sentence states a specific verb+resource: 'Add a node to call a Blueprint Interface function on a target object.' This clearly conveys what the tool does. It doesn't explicitly differentiate from the near-identically named sibling bp_add_call_interface_function, and the conceptual focus on interfaces-vs-casting only indirectly separates it from add_cast_node and add_blueprint_function_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 explains the conceptual advantage of interfaces ('you can call functions on unknown object types safely' vs 'direct casting'), which implies when this tool is appropriate. However, it never names alternatives or states explicit when-to-use/when-not-to-use conditions, leaving the agent to infer selection criteria from the interface-vs-casting discussion.

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 provides useful domain context about Canvas Panels but does not describe the tool's actual side effects, whether an existing root panel is replaced, idempotence, failure modes, or what changes occur to the target widget blueprint beyond 'Add'.

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 well-structured: a one-line purpose, brief conceptual context, Args list, KB reference, and example. It is concise and front-loaded, with no significant padding, though the 'From Ch. 7' framing is slightly extraneous.

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 an output schema present, return values need not be explained, and the example provides a usable call pattern. However, the tool has no annotations and the description omits preconditions (e.g., widget blueprint must exist), whether the panel is created as a root component, and what happens if a panel already exists. It is minimally sufficient but not 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 0%, so the description must compensate. It does provide an Args block explaining widget_name as 'Widget Blueprint name' and panel_name as 'Component name for the Canvas Panel', plus an example path. This is helpful but still minimal, lacking path format details, constraints, or how the two parameters interact.

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 Canvas Panel to a Widget Blueprint'. It further clarifies intent with '(free-placement layout)', which differentiates it from sibling tools like add_horizontal_box_to_widget or add_text_block_to_widget.

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

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

The description implies when to use it by explaining that Canvas Panel allows absolute positioning and is the default root panel for most UMG widgets. However, it does not explicitly name alternatives or state when not to use this tool versus other layout panels.

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 clearly states the tool adds a node and mentions the performance cost of capsule traces. However, it does not disclose side effects such as whether the blueprint is modified/persisted, whether the graph needs compilation, or whether other nodes are reconnected.

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 well organized: purpose, rationale, args, KB reference, and example. It is front-loaded with the core function, and every section contributes actionable information without unnecessary verbosity.

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 node-addition tool this is largely complete: it names all required concepts, provides defaults via schema, gives an example, and links to knowledge base context. The main gap is the absence of explicit values for draw_debug, and it does not mention prerequisites like an existing blueprint graph.

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

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

Schema description coverage is 0%, so the description must compensate. It adds useful semantics for trace_channel ('Visibility' or 'Camera') and node_position ('Optional [X, Y] graph position'), and the example illustrates blueprint_name format. However, draw_debug remains vague as 'Debug visualization type', with no valid values explained.

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

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

The description states a clear action and resource: 'Add a Capsule Trace By Channel node'. It further distinguishes itself from LineTrace by explaining the capsule volume and character-sized sweep use case, making the tool's purpose specific rather than a tautology.

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

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

The description gives concrete usage context: capsule trace is 'more expensive than LineTrace' but covers a volume, and is 'useful for character-sized sweeps'. This implies when to prefer it over LineTrace, though it does not explicitly address alternatives like SphereTrace or BoxTrace.

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