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 describes the deletion action but does not mention potential side effects (e.g., whether deletion is permanent, unwinds, or affects attached components), nor does it warn about destructive consequences. The only added context is clarifying the meaning of 'label,' which is useful but insufficient for a destructive operation.

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

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

The description is a single, concise sentence that front-loads the key action and immediately clarifies the parameter. Every word earns its place, with no redundancy or unnecessary detail.

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

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

For a simple tool with one parameter and no output schema, the description is adequate but lacks key safety context for a destructive operation. It does not explain what happens if the label does not exist, whether the action is reversible, or any prerequisites (e.g., listing actors first). With sibling tools like list_actors available, a mention of how to discover valid labels would improve completeness.

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

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

The input schema provides no description for the 'label' parameter (0% coverage), but the description compensates by explaining that the label is the editor label (World Outliner name). This adds meaningful context to the single parameter, though it does not specify format, uniqueness, or case sensitivity. Given the minimal schema, this is strong compensation.

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

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

The description clearly states the action ('Delete the actor') and identifies the target resource by its editor label (World Outliner name). This distinguishes it from sibling tools like list_actors, spawn_actor, or duplicate_actor, which have different purposes.

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

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

The description implies the tool is used to delete an actor identified by label, which is a clear context. However, it does not explicitly state when to use this tool over alternatives, nor does it mention any prerequisites or exclusions (e.g., 'cannot delete actors with children'). The usage guidance is implied rather than explicitly 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, the description must fully disclose behavior. It states the main action and optional effects (offset, new label), which implies the original actor is unchanged. However, it does not mention return values, whether the duplicate is selected, error conditions (e.g., missing label), or potential side effects. The description is not misleading, but it lacks deeper behavioral context.

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

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

The description is a single, well-structured sentence that front-loads the action and mentions all optional behaviors without extraneous words. It is concise and clear.

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 core operation and parameters, but given the absence of annotations and an output schema, it should provide more context about the result (e.g., what is returned or changed), error behavior, or selection state after duplication. It is adequate for a simple tool 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 coverage is 0%, so the description must compensate. It explains each parameter: 'label' as the actor to duplicate, 'offset' as a world location offset, and 'new_label' as an editor label. This adds meaning beyond the schema, though it does not specify the exact format or units for the offset beyond 'world location'.

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 ('duplicate') with a resource ('actor') and clearly identifies the target by label. It also distinguishes this from siblings like 'delete_actor' and 'spawn_actor' by the action and optional behaviors.

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

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

The description implies usage: duplicate an existing actor. It does not explicitly mention when to use this tool versus alternatives like 'spawn_actor' for creating new actors or 'delete_actor' for removal. No exclusions or alternative comparisons are given, so guidance is implied 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?

With no annotations provided, the description carries the full burden. It discloses modes, return structure, and constraints (single expression vs multi-line script). However, it does not warn about potential side effects or irreversible changes, which is a notable gap for an arbitrary code execution 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 begins with a one-sentence summary, then gives usage guidance with examples, followed by clearly labeled Args and Returns sections. It is well-structured, front-loaded, and every sentence adds value without unnecessary digression.

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 (arbitrary code execution), minimal schema, no annotations, and no output schema, the description is complete: it covers what it does, when to use it, parameter values, and the exact return format. There is no missing information needed for correct selection and invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains both parameters: 'code' with mode-specific constraints, and 'mode' with each valid value ('file', 'statement', 'eval') and its behavior. This goes beyond the raw schema and provides exact semantics.

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

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

The description clearly states 'Run arbitrary Python code inside the UEFN editor's unreal module', using a specific verb and resource. It also distinguishes itself from sibling tools by framing it as a fallback when 'dedicated tools aren't enough', with concrete examples like browsing content and inspecting classes.

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?

Yes, it explicitly says to use this tool when dedicated tools aren't enough and provides examples of appropriate use cases (e.g., calling APIs not wrapped by other tools). This implies dedicated tools are the preferred alternatives for their specific purposes, giving clear when-to-use guidance.

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

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

With no annotations, the description bears the full transparency burden. It discloses that the tool returns location/rotation/scale and implies a read-only operation, but it does not specify behavior for invalid labels, return format details, or error handling. This is partial transparency, sufficient for a simple getter but lacking edge-case context.

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

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

The description is a single, front-loaded sentence that directly states the tool's function and parameter role. There is no redundant information or unnecessary detail, making it highly efficient.

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 one parameter and no output schema, the description covers the essential purpose and input. It indicates the return data (world transform) but does not specify exact return structure or error behavior. Given the simple nature, this is nearly complete, only slightly lacking in output precision.

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 clarifying that the 'label' parameter identifies the actor ('with the given label'). It clearly ties the parameter to its purpose, though it does not elaborate on label format or constraints. This 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 uses a specific verb 'Get' and a clear resource 'world transform (location/rotation/scale) of the actor with the given label'. It distinguishes itself from sibling tools like set_actor_transform (which mutates) and list_actors (which lists actors) by explicitly stating the action and scope.

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

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

The description implies when to use the tool (to retrieve an actor's transform) but provides no explicit exclusions or alternatives. It does not mention that set_actor_transform is for modifying transforms or that list_actors can be used to find labels, so guidance is only implied rather than stated.

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

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

With no annotations provided, the description carries the full burden. It explicitly indicates a read-only status operation through 'check' and 'report' and enumerates the output fields, which is transparent for a simple status tool. It does not cover edge cases like disconnection errors, but this is acceptable given the tool's simplicity.

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

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

The description is a single, well-structured sentence that front-loads the action ('Check connectivity and report') and uses a parenthetical list to compactly present the output items. Every part is informative with no wasted words.

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

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

For a zero-parameter, no-annotation, no-output-schema tool, the description is complete: it explains the purpose, the output content, and the connected editor context. The sibling tools are clearly different, and the description provides enough information to invoke and interpret 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 tool has zero parameters and an empty input schema, so the description does not need to add parameter semantics. Baseline 4 applies due to the absence of parameters; the description correctly omits any parameter discussion.

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 checks connectivity and reports basic editor info, listing specific items like project file, level name, engine version, and actor/selection counts. This is a specific verb+resource combination that distinguishes it from sibling tools, which focus on actors, assets, and editor operations.

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

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

The description implies the tool is for verifying connectivity and getting an overview of the editor state, but it does not explicitly state when to use it versus alternatives or any preconditions. No alternatives are mentioned, so usage guidance is only implicit.

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

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

With no annotations available, the description carries the burden of behavioral disclosure. It states a read-only action ('Return') and clarifies the scope ('UEFN editor viewport/outliner'), but it does not mention output format, edge cases (e.g., empty selection), or any potential side effects. It is not misleading, but it lacks depth that would help an agent anticipate behavior beyond a simple fetch.

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

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

A single sentence, front-loaded with the action and object, with no filler words. Every word earns its place; it is an ideal length and structure.

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

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

This is a simple getter with no parameters and an output schema present. The description fully explains the tool's function in its domain ('selected actors'). No further detail is needed, especially since the output schema covers return structure.

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 zero parameters, so there is nothing to document. Per baseline for 0-parameter tools, the description adequately fulfills the need by explaining what the tool does without requiring parameter context. The description adds no parameter detail because none exists.

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 ('Return') and resource ('actors'), and scopes it precisely to 'currently selected in the UEFN editor viewport/outliner'. This clearly distinguishes it from siblings like list_actors (which lists all actors) and get_actor_transform (which gets a property of an actor).

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

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

The context is clear: this tool is for retrieving the current selection in the editor. It implies the appropriate use case without explicitly naming alternatives or exclusion scenarios. The description is sufficient for an agent to know when to use it, though it does not provide explicit 'when not to use' guidance.

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

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

With no annotations, the description must disclose behavioral traits. It adds context about the 'loaded level' scope, but doesn't explicitly state that the operation is read-only, doesn't mention ordering or performance characteristics, and doesn't clarify what happens if no level is loaded. It 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 concise, front-loaded with the main purpose, and structured with a clean Args block. Every sentence contributes meaning without repetition or fluff.

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

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

For a simple list tool with an output schema, the description is fairly complete: it explains purpose, scope, and parameters. However, it doesn't address usage guidance or potential edge cases like empty levels, which keeps it from being a 5.

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

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

The description adds full meaning for both parameters beyond the schema. It explains class_name as a case-insensitive substring filter with an example, and limit as a maximum count. Since schema descriptions are absent (0% coverage), this substantial explanation is valuable.

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 'List actors currently placed in the loaded level' with a specific verb 'list', a clear resource ('actors'), and a scope ('in the loaded level'). This clearly differentiates from sibling tools like get_selected_actors or list_content_assets.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention that get_selected_actors should be used for a subset, or that delete_actor/spawn_actor are related. Usage context is only implied by the tool name.

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 indicates a non-destructive 'browse' action and documents filtering/flags, which is helpful, but it does not explicitly state that it causes no modifications, nor does it mention potential performance implications or how recursion behaves in edge cases.

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: a one-sentence purpose followed by a neatly formatted Args list. Each line adds necessary information without redundant filler, striking a good balance between detail and brevity.

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

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

The description provides sufficient operational detail for a straightforward listing tool: purpose, all parameters, and exemplars. Since an output schema exists, the description need not explain return structure. It falls short of a perfect score only by omitting explicit non-mutation guarantees or usage boundaries, though these are strongly implied.

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 zero description coverage, so the description fully compensates by explaining each parameter with concrete examples (e.g., path: '/Game/Devices', class_names: ['StaticMesh', 'Blueprint']). This directly addresses the schema gap and gives the agent actionable meaning for every argument.

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 'Browse assets in the content browser,' which is a specific verb + resource, clearly differentiating it from sibling tools like list_actors (which targets actors). It further clarifies scope with examples like props, Blueprints, and materials.

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 implicitly conveys usage by defining the tool's purpose and parameters, but it lacks explicit when-to-use guidance or direct comparison to alternatives. There is no mention of when to prefer this over list_actors or other content-browser 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 explains the basic save behavior and the all_dirty option, but does not reveal important traits such as whether saving overwrites existing files, what 'dirty' means, or what happens if no level is open. 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 two sentences and 15 words, front-loaded with the primary action. Every phrase adds value, including the conditional all_dirty behavior, with no redundancy or filler.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the core behavior and the parameter's effect. It could benefit from clarifying 'dirty' and prerequisites (e.g., requires an open level), but overall it is sufficiently complete for its simplicity.

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

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

The schema provides only the type and default for all_dirty, with no semantic description. The tool description compensates by explaining the effect of setting all_dirty to True, which clearly defines the parameter's meaning in context.

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 saves the current level, with a specific verb 'Save' and resource 'level'. It also differentiates the all_dirty variant, which distinguishes it from the sibling tools that focus on actors and content assets.

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

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

The description provides clear context for when to use this tool (to save a level) and explicitly specifies the conditional behavior for all_dirty=True. It does not enumerate exclusions or alternatives, but the context is unambiguous among the sibling tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key behavior: fields left unset remain unchanged. However, it does not mention coordinate systems, units, success/failure behavior, or any side effects. This is a moderate level of transparency.

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

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

Two concise sentences with the primary action front-loaded. No wasted words; every phrase adds value.

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

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

The tool is a simple setter with four parameters and no output schema. The description covers its purpose, parameter behavior, and the partial-update nuance. It does not describe return values or validation, but for a straightforward mutation tool, the provided context is reasonably complete.

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

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

The schema has 0% description coverage, so the description must compensate. It explains that location, rotation, and scale are optional and that leaving them unset (null) preserves existing values. This adds meaningful semantics beyond the raw schema, which only shows defaults and null 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 clearly states the tool's action (move, rotate, scale) and target (the actor with a given label). This distinguishes it from siblings like get_actor_transform, which reads the transform, and delete_actor, which removes an actor.

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

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

The description provides clear context: it is used to modify an actor's transform, and unset fields are left unchanged. It does not explicitly name alternatives or exclusionary conditions, but the context is sufficient for an agent to infer when to use this tool over read-only or other mutation tools.

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

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

No annotations are present, so the description must carry the burden of behavioral disclosure. It reveals defaults, units (cm, degrees), and the fact that spawning occurs into the loaded level. However, it does not cover failure behavior, return values, or persistent side effects, leaving some ambiguity for 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 concise and well-structured: a one-sentence summary followed by a clean Args block. Every sentence contributes value, with no redundancy or filler.

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

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

With 5 parameters, no output schema, and no annotations, the description does a good job covering all parameters and providing usage context for discovering class paths. However, it omits details about return values and error handling, which would be useful given the lack of an output schema. Overall, it is fairly complete but not exhaustive.

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 fully compensates by explaining each parameter in detail: class_path format with examples, location/rotation/scale key names and units, defaults, and label semantics. This adds substantial meaning beyond the raw schema.

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

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

The description opens with 'Spawn an actor into the loaded level', which is a specific verb+resource statement. It clearly distinguishes this tool from sibling tools like delete_actor and duplicate_actor by focusing on creation from a class path.

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

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

The description provides clear context for when to use the tool (to create an actor) and even directs users to `list_content_assets` or `execute_python` for discovering valid class paths. However, it does not explicitly contrast with alternative tools like duplicate_actor or 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.