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

With no annotations, the description must carry the full behavioral burden. It does disclose meaningful matching semantics (space-separated terms matched against relative path and robot alias), which goes beyond structured data, but it omits case sensitivity, whether terms are ANDed or ORed, result ordering, and what happens when the limit truncates results.

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 tight sentences, front-loaded with the verb and resource, followed by the matching rule and the kind filter. Zero padding and no restatement of the name.

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

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

For a tool with no annotations, 0% schema description coverage, and no output schema, the description is adequate but thin: it never explains limit behavior, match combination logic, or result shape, which an agent needs in order to query reliably and interpret truncated results.

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 does explain `query` semantics and enumerates `kind: all|model|scene`, covering two of the three parameters; however, `limit` (default 50) is never mentioned, so the truncation behavior of results is undocumented in both schema and description.

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

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

States a specific verb and resource: it searches CoppeliaSim model (.ttm) and scene (.ttt) files, and names the fields matched (relative path, robot alias). The scope is clear enough to separate it from siblings like coppelia_import_model or coppelia_scene, though it never explicitly says how it differs from those.

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 a discovery/lookup use case but gives no explicit when-to-use, when-not-to-use, or alternatives. An agent is left to infer that this is the catalog lookup step before coppelia_import_model, with no statement of prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and does disclose real behavioral facts: episode cap of 20, per-episode scene reload, combined step cap of 10000, and that joint positions/diagnostics/success conditions are produced. It omits blocking behavior, what happens to simulator state, and error handling on episode 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?

A single dense sentence that front-loads the action and the two hard caps. Nothing is wasted, though the semicolon-clause packing makes it read like a feature list rather than prioritized guidance.

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 6-parameter tool with a required array-of-objects 'episodes' argument, no output schema, and no annotations, the description is far too thin. An agent cannot construct a valid episode entry or know what sample_every/headless/sensors do from this text alone.

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

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

Schema coverage is 0% across 6 parameters, so the description must explain them and largely does not. It hints at initial_scene ('explicit scene') and episodes, and loosely at observe ('joint positions, diagnostics'), but headless, sample_every, sensors, and the structure of each episode object are entirely undocumented.

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

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

States a specific verb and resource ('Run ... simulation episodes') plus concrete scope limits (up to 20 episodes, explicit scene, 10000 combined steps). It implicitly separates itself from single-step siblings like coppelia_step/coppelia_simulate by being a batch-episode runner, but never names them.

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

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

The word 'experiments' and the 20-episode/10000-step caps imply this is for multi-episode batch evaluation rather than single stepping, but there is no explicit 'use this instead of coppelia_simulate when...' guidance or prerequisite statement.

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

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

No annotations exist, so the description carries the full burden, and it only covers the non-mutating aspect. It says nothing about what happens when the simulator is unreachable (raises vs. reports a degraded status), any connection timeout, or whether a partial result is returned when simIK is missing but simOMPL is present — all critical for a health probe.

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 short sentences, front-loaded with the actual checks and followed by the negative boundary. Nothing redundant and nothing that merely restates the tool name.

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

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

For a two-parameter read-only probe the enumerated checks roughly imply the return payload, and no output schema exists to do that job. Still, with no annotations and undocumented parameters, an agent lacks guidance on connection failure semantics and endpoint configuration — gaps the description should have closed.

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%: host and port are bare typed fields with defaults and no explanation. The description never mentions either parameter, so nothing clarifies that host/port target the ZeroMQ endpoint or what happens if the simulator listens elsewhere. With zero coverage the description should compensate and does not.

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

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

A specific verb (check) paired with three explicitly enumerated resources: the ZeroMQ connection, the simulator version, and runtime availability of simIK/simOMPL. That inventory makes it instantly distinguishable from the action-oriented siblings (coppelia_step, coppelia_simulate, coppelia_motion), which none of the other tools could be confused with.

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 sentence 'Does not launch or modify the scene' gives a useful negative boundary, telling the agent this is a diagnostic probe rather than a scene operation. But it never states the positive trigger — e.g. call this before coppelia_motion to confirm simIK is available, or to diagnose a dead ZeroMQ connection. Usage is implied rather than directed.

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 supplied, so the description carries the full burden, yet it does not disclose that this mutates the scene by instantiating objects, whether existing scene content is affected, whether a running CoppeliaSim instance is required, or what headless/respondable do. Only the word 'Create' implies mutation, which is not enough for a scene-mutating tool with zero annotation coverage.

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

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

A single, front-loaded sentence with no filler; it is efficient, though it is arguably too terse given the tool's parameter 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?

For a 10-parameter (8 required) scene-construction tool with no annotations, no output schema, and undocumented parameters, the description is far too thin. An agent could not reliably choose values for the six required numeric/range parameters from this text alone.

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

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

With 10 parameters and 0% schema description coverage, the description needs to compensate heavily but only hints at the domain (grayscale pixel classification). It never explains what wall_range/door_range/window_range integer arrays mean (presumably intensity thresholds), what units pixel_size uses, or what headless and respondable control.

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 gives a specific verb ('Create') and a precise resource ('static cuboid segments from grayscale floor-plan pixels classified as walls, doors, and windows'), which clearly separates it from siblings like coppelia_import_model or coppelia_scene. It just stops short of naming an alternative explicitly.

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 versus coppelia_import_model or coppelia_scene, nor any prerequisite such as needing an active simulation or a specific image format. The agent must infer usage entirely from the purpose sentence.

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 indicates that importing creates roots and reports joint counts, but it omits important side effects such as whether it mutates the current scene, how existing objects are handled, what happens on failure, and what headless mode changes.

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

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

A single tightly written sentence that front-loads the action and supported formats, then states the reported outputs. No wasted text.

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

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

For a mutation-capable import tool with six undocumented parameters, no annotations, and no output schema, the description is too thin. It gives the file formats and a partial return summary but lacks sufficient behavioral and parameter context for confident 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% across six parameters. The description mentions file formats relevant to path but does not explain scale, headless, position, orientation, or package_root, leaving most parameters undocumented in both schema and description.

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

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

States a specific verb (Import) and resource (URDF, SDF, STL, OBJ, or DAE files), and notes the reported outputs (roots and joint counts). It is fairly easy to distinguish from coppelia_import_floorplan, though it does not explicitly name that sibling.

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 supported file formats imply when the tool is applicable, but there is no explicit guidance on when to use it instead of coppelia_import_floorplan or other scene-building tools. No prerequisites or exclusions are stated.

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

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

No annotations exist, so the description carries the full burden. 'Inspect' and 'report' imply a read-only operation, and the enumerated field list is genuinely useful behavioural context, but nothing is said about what happens with an invalid or nonexistent root_path, whether it errors or returns empty, or whether it is safe to call repeatedly. Adequate but incomplete for an unannotated tool.

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

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

One front-loaded sentence with no filler; the verb and scope come first and the payload enumeration follows. Dense without being cryptic. A slightly clearer separation between 'inspect' and 'report' clauses would have earned a 5.

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

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

There is no output schema, and the description usefully compensates by listing the returned fields (joint types, limits, positions, base and end-effector candidates). However, the input side is left entirely open (path format, error behaviour) and there is no annotation coverage, so the definition is only just sufficient 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%: root_path is a bare string with no title beyond 'Root Path' and no format hint. The description mentions 'robot subtree', which loosely ties the parameter to a scene-tree concept, but it never says whether the path is a slash-delimited scene path, a handle, or an alias. With a single undocumented parameter, the description needed to compensate and does not.

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

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

The description names a specific verb (inspect) and resource (robot subtree) and enumerates exactly what it reports: joint types, limits, positions, sensors, base and end-effector candidates. That is far more informative than the opaque tool name. It stops short of 5 because it never contrasts with near-neighbours such as coppelia_sensors or coppelia_scene, so an agent must infer the boundary from the report contents.

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 statement of when to call this versus the many sibling tools, nor any prerequisite such as loading a scene first. The only guidance is implicit in the enumerated outputs. With seventeen siblings, an explicit 'use this before motion planning / instead of coppelia_sensors' note would have been cheap and valuable.

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-disclosure burden. It usefully states that planning returns a path and never applies it to robot joints, but it does not say whether operation='ik' mutates robot state, what permissions are required, what happens on failure, or how headless mode affects 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 front-loaded, with no filler text. The dense inline parameter listing is efficient but reads more like a schema summary than structured usage guidance.

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 16-parameter motion tool with no annotations, no output schema, and zero schema description coverage, the description is insufficient. It leaves several parameters undocumented and does not explain the return path format, error cases, or the side-effect profile of the IK operation.

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

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

Schema description coverage is 0% across 16 parameters. The description maps 12 parameters to the 'ik' and 'plan' operation modes, which adds useful grouping beyond the bare schema, but it omits damping, iterations, headless, and does not explain the meaning or allowed values of constraints, method, or algorithm.

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 that this tool provides typed motion operations and enumerates operation='ik' and operation='plan' with associated parameter sets, so an agent can tell it handles inverse kinematics and motion planning. It does not distinguish this tool from siblings such as coppelia_trajectory or coppelia_step.

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 operation-specific parameter usage for 'ik' versus 'plan' and notes that planning returns a path without applying it to robot joints, which implies when to choose plan versus execution. However, it gives no explicit when-to-use guidance versus sibling tools, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full burden and only partially delivers: it discloses the 2–5 scene bound, that episodes are identical across scenes, and that each scene keeps its own physics engine. It says nothing about whether simulation state is mutated or reset, how long runs take, whether scenes are paths or handles, or what a 'comparison' result looks like — critical given there is no output schema.

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 dense sentence with the core action front-loaded and no filler; the trailing clause about retaining the configured physics engine earns its place by explaining the comparison's validity. Slightly cryptic phrasing ('caller-prepared', 'bounded episodes') costs it the top mark.

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 high-complexity tool with six parameters, nested objects, no annotations, and no output schema, the description is far too thin. It should at minimum explain what the four undocumented parameters do and what the caller receives back, since nothing else in the definition supplies that.

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% across six parameters including nested objects, and the description only gestures at two of them ('scenes' as caller-prepared with a configured physics engine, 'episodes' as identical and bounded). The semantics of observe, sensors, headless, and sample_every — including whether sample_every is per-episode or global — are entirely undocumented.

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

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

States a specific verb (run) and resource (identical bounded episodes across 2–5 scenes) plus the outcome (compare task outcomes), which is far more informative than a name restatement. It does not, however, differentiate itself from close siblings like coppelia_experiments or coppelia_simulate, so an agent still has to infer which one to reach for.

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 '2–5 caller-prepared scenes' and 'identical bounded episodes' implies the preconditions for use (scenes must already exist, episodes must be comparable), but there is no explicit when-to-use, when-not-to-use, or named alternative among the many simulation siblings. Usage is inferable 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?

Since no annotations were provided, the description carries the full burden of behavioral disclosure. Stating that the simulation must be stopped to make changes is a major behavioral constraint that would otherwise be unknown to the 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 a single, highly efficient sentence that front-loads the core purpose while placing necessary constraints and hints at the end. There is no superfluous language.

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 complete lack of structured metadata (0% schema coverage, no annotations), the description is exceptionally complete, covering functionality, required state for changes, and data format hints for complex parameters.

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

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

With 0% schema description coverage, the description provides vital semantic information. It defines the format of the 'engine_property' argument as '[index, version],' guiding the agent on how to structure this specific input.

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 and specifically states the function (Inspect or set) and the resource it acts upon (scene physics engine property and dynamics step size). It distinguishes its purpose as a configuration tool, distinct from general simulation or catalog 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?

It provides a critical precondition for modification: 'Changes require simulation stopped.' This is a vital usage guideline that prevents agents from attempting mutations that would fail at runtime.

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 only discloses that recording is bounded/per-step and outputs JSON. It never warns that the tool likely launches a simulation, may stop it (stop_on_finish), runs headless, or has side effects on the current simulator state—all significant traits an agent needs before invoking a 9-parameter 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 single sentence is dense and front-loaded with no filler, which is structurally efficient. Its brevity is a liability only because it under-specifies, which is better captured by the completeness dimension.

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

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

For a complex 9-parameter tool with no annotations and no output schema, one sentence is far too thin. The description omits parameter behavior, simulation side effects, and result/export semantics, leaving the agent with substantial gaps before it can call the tool correctly.

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

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

Schema description coverage is 0%, so the description must explain the nine parameters, but it only vaguely gestures at steps/until ('bounded'), sensors, and JSON export. Key parameters like observe, headless, max_samples, sample_every, and stop_on_finish are never clarified, leaving half the inputs undocumented.

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

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

The description names a specific verb (Record) and concrete resources (simulation state, typed sensor samples) plus the output format (JSON), which is far more informative than a title restatement. It does not explicitly contrast itself with siblings like coppelia_step or coppelia_sensors, so it falls short of a 5.

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

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

There is no indication of when to choose this tool over coppelia_step, coppelia_simulate, or coppelia_sensors. 'Bounded, per-step synchronized' hints at a recording workflow but does not state prerequisites or exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies side effects by mentioning publish, capture, and send action goals, but it does not disclose blocking behavior, timeout semantics, rate limits, runtime prerequisites, or failure modes for a multi-modal ROS 2 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 description is a single front-loaded sentence with no filler, which is structurally efficient. However, it is under-specified for a tool with 11 parameters and multiple operation modes, so conciseness comes at the cost of necessary 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?

This is a complex 11-parameter tool with no annotations, no output schema, and no schema descriptions, yet the description provides only a broad list of ROS 2 interaction categories. It leaves operation values, parameter roles, return behavior, and safety/blocking characteristics entirely unspecified.

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% across 11 parameters, and the description does not mention any parameter names or meanings. Critical parameters such as operation, name, interface_type, rate, count, payload, duration, and feedback_topic are left completely undocumented beyond bare titles.

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 specific verbs (publish, echo, capture, stream, call, send) and resources (ROS 2 topics, services, action goals) within the CoppeliaSim ROS 2 Humble runtime. However, it does not differentiate this tool from the sibling coppelia_ros2_status, so an agent cannot tell when this tool is preferred over status.

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, including the closely named coppelia_ros2_status sibling. The description also does not clarify which operation to choose for a given task or mention prerequisites for interacting with the ROS 2 runtime.

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

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

With no annotations, the description carries the full burden, and it does disclose the key safety traits: read-only in effect, no scene mutation, no ROS 2 startup. It stops short of describing what a failure looks like (returned error, exception, boolean) or whether the tool spins up a simulator instance at all, which the 'headless' parameter hints at.

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 short sentences, the purpose first and the scope disclaimer second. No filler, nothing to trim.

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 one-parameter status check with no output schema, the description covers what is checked and what is not done. It is incomplete on the one thing the schema leaves blank — the meaning and side effects of 'headless' — and on what a positive/negative result looks like.

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

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

Schema description coverage is 0% and the single parameter 'headless' (default false) is never mentioned in the description. An agent cannot tell whether headless=true launches a GUI-less simulator process or merely affects how the plugin check is performed, which is a meaningful behavioral difference left undocumented.

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

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

Specific verb+resource: 'Check whether the installed CoppeliaSim simROS2 plugin loads' tells the agent exactly what is being verified. It partially differentiates itself from the sibling coppelia_ros2 by disclaiming that it does not start ROS 2, but it never names that sibling or describes how the two relate.

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?

'This tool does not start ROS 2 or alter the scene' is a useful exclusion that implies coppelia_ros2 is the tool for actually starting the bridge. However, no alternative is named and no precondition is given (e.g., run this before coppelia_ros2 to verify the plugin is installed).

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 at all, the description carries the full burden, and it does deliver the key hazard: load stops the running simulation and replaces the current scene. It omits other load-bearing behavior such as whether save overwrites an existing file, what happens if the path is invalid, and what the call returns.

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

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

Two sentences and a terse param list, with the core purpose and hazard front-loaded ahead of parameter notes. The telegraphic 'action: save|load' style is compact and earns its space, though the sentence fragments read slightly as notes rather than 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?

For a 3-parameter, annotation-free mutation tool with no output schema, the description covers purpose, one parameter constraint set, and the destructive side effect of load, but leaves headless undefined and says nothing about save semantics or failure modes.

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 documents the two required parameters with useful constraints ('action: save|load', 'path: absolute .ttt path') that the bare string schema does not convey, but leaves the third parameter (headless) completely undocumented in both schema and text.

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 pair and resource ('Save or load a CoppeliaSim scene') plus the discriminating parameter values (action: save|load), so the agent can distinguish it from siblings like coppelia_import_model or coppelia_step. It stops short of explicitly saying how it differs from related scene-importing 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?

Usage is only implied: save vs load is selectable via the action field, and the destructive nature of load hints at caution. There is no explicit 'use this when...' guidance and no mention of when to prefer coppelia_import_model or coppelia_import_floorplan over loading a .ttt scene.

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 implies a read-only operation through the verb 'Read' but does not disclose permissions, error handling, units, ordering, snapshot semantics, or behavior for missing/invalid sensor paths. It adds the useful detail that paths are typed and that multiple data modalities are supported, but this falls short of the transparency needed for a sensor-reading tool with zero annotation coverage.

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

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

The description is a single front-loaded sentence with no wasted words, efficiently naming the action and the data categories. It could be slightly clearer or more structured, but it is appropriately sized for the tool's surface.

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 no annotations, no output schema, and a complex array-of-objects parameter with zero schema description coverage, the description leaves major gaps. It does not explain the shape of sensor entries, return format, units, or selection semantics, so an agent would need to inspect external documentation to call it reliably.

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 for its single required parameter, an array of objects, and the description does not compensate by explaining the object shape, required fields, or how to specify a typed sensor path. It adds only the high-level notion of 'typed sensor paths' and data-type categories, which is insufficient to invoke the tool correctly without inspecting undocumented nested objects.

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, 'Read', and a clear resource: sensor data from typed sensor paths. It enumerates supported data types (proximity, vision RGB, metric depth, force/torque, point-cloud), making the tool's purpose distinguishable, though it does not explicitly differentiate itself from siblings such as coppelia_signals.

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, nor any prerequisites or exclusions. The phrase 'read selected ... data' implies a selective read but does not tell the agent under what circumstances to choose coppelia_sensors over related tools like coppelia_signals.

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

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

There are no annotations, so the description carries the full behavioral burden. It discloses that writes are possible, but it says nothing about permissions, whether writing overwrites existing values, side effects, the role of 'headless', or error behavior. This is a significant gap for a mutation-capable 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-loads the main capability, which is good. However, the second sentence about not being a PLC network adapter is abrupt and does not clearly earn its place as a disambiguation.

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 tool with no annotations, no output schema, and zero schema description coverage, the description is too thin. It identifies the resource but leaves key calling details undocumented.

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 the five parameters. It only maps the signal value type to integer, float, or string and implies a read/write operation. It does not clarify accepted values for 'operation' or 'signal_type', requiredness, or what 'headless' controls.

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

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

The description states a specific verb pair ('Read or write') and resource ('named integer, float, or string CoppeliaSim signal'), which is enough for an agent to grasp the tool's function. The negative clarification about not being a PLC network adapter is confusing, but sibling differentiation is implicit because no other coppelia_* tool handles signals.

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 only implies that read and write are the supported operations. It does not say when to choose this tool over alternatives, what prerequisites exist, or what values 'operation' accepts. An agent must infer all usage conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that results include positions and proximity sensor samples and that export_path writes a .json file, but it does not disclose simulation-state side effects, whether file writes overwrite existing data, or how headless mode changes behavior.

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

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

The description is short and front-loaded with the main action and return behavior. The compact 'until' schema notation is efficient, though the overall terseness leaves important parameter and behavioral gaps.

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 comparatively complex tool with 7 parameters, no annotations, and no output schema. The description covers the core action and return shape but is not complete enough to explain the remaining parameters or the full side-effect profile.

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

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

Schema description coverage is 0% for 7 parameters, so the description must compensate. It adds useful syntax for 'until' and export_path and implies 'steps', but leave observe, sensors, headless, and sample_every completely undocumented.

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

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

States a specific verb and resource: 'Step CoppeliaSim N times', with the stopping condition 'or until a diagnostic issue'. The batch-stepping scope distinguishes it somewhat from a single-step sibling, but it does not explicitly contrast itself with coppelia_step or coppelia_sensors.

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

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

The description implies usage through 'N times' and the 'until' diagnostic condition, suggesting this is for multi-step simulation with an early stop. However, it gives no explicit guidance on when to choose this over coppelia_step, coppelia_sensors, or other siblings, and no alternatives are named.

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 to lean on, the description carries the full burden and does so thoroughly: it discloses auto-launch behavior, the exact snapshot paths written, the shape of the `scene_objects` return, the `scene_hierarchy_error` failure signal, and mutation side effects (spawning/removing objects). An agent knows the observable behavior and side effects before calling.

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 definition is bloated with repeated all-caps directives and duplicated warnings, and it front-loads a shouting protocol notice ahead of the actual tool summary. The genuinely useful material (return format, API cheat-sheet) is buried under rhetorical 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 code-execution tool with no output schema, the return behavior is described well (two PNG paths, scene hierarchy, diagnostics results). However, the three undocumented parameters and the absence of any note on what `reset`/`timeout` do leave real gaps 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 document all five parameters, yet it only explains `diagnostics` (with a concrete example payload) and implicitly `code`. `reset`, `timeout`, and `headless` are never defined, so an agent must guess their semantics 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 'TOOL SUMMARY' block states a specific verb and resource: execute Python code inside CoppeliaSim, auto-launch the simulator, capture dual snapshots, and return results in one call. It is concrete and distinguishable, but it never explicitly contrasts itself with siblings like coppelia_simulate or coppelia_scene, leaving the differentiation to inference.

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 gives strong procedural guidance for *how* to use the output (inspect both PNGs, check hierarchy before spawning), but no guidance on *when* this tool should be chosen over coppelia_simulate, coppelia_scene, or coppelia_motion. Usage context is implied rather than stated against 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 full burden, and it does disclose meaningful behavior: per-step collision checks, dynamic-contact grasp checks with post-lift retention and slip limits, and distance-based place checks. It says nothing about blocking vs. async execution, what happens on a failed check (abort? raise?), or the effect of headless mode.

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

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

One front-loaded sentence with no filler, but it is an overstuffed clause chain that is hard to parse. Structure would improve by splitting the limits from the validation checks.

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

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

For a 9-parameter motion execution tool with no annotations, no output schema, and zero schema descriptions, the description leaves major gaps: parameter shapes, gripper action format, failure semantics, and return values are all unaddressed.

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

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

Schema description coverage is 0% across 9 parameters, so the description must compensate and largely fails. It hints at max_velocity, max_acceleration, and max_jerk, but says nothing about joints, trajectory, collision_pairs, gripper_actions, steps_per_waypoint, or headless, all of which are undocumented everywhere.

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 concrete verb+resource: executing a joint path with velocity/acceleration/jerk limits plus collision and grasp checks. It is specific about what the execution validates. However, it never distinguishes itself from siblings like coppelia_motion, coppelia_step, or coppelia_simulate, which plausibly also move a robot.

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 indication of when to use this tool versus coppelia_motion or coppelia_step, no prerequisites, and no exclusions. The agent must infer routing 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.