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

The description adds meaningful side-effect details beyond the annotations: it frees model and data, invalidates the session_id, and returns a JSON shape with remaining sessions. This is consistent with destructiveHint=true and idempotentHint=false, with no contradiction.

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-structured: action and consequence first, invalidation note second, return format third. Every sentence contributes useful information without 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 simple single-parameter destructive cleanup tool, this description covers the action, side effects, and return shape sufficiently. The explicit JSON return format is especially helpful since the output schema is not fully available in context.

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

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

With 0% schema description coverage, the description must compensate for the session_id parameter. It does show the parameter in context and states it becomes invalid, which adds some meaning, but it does not explain where a valid session_id comes from or its expected format. The single-parameter context makes this moderate rather than severe.

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 object: 'Close a session and free its model and data.' It clearly distinguishes this from close_viewer and session-listing tools by focusing on session lifetime and resource cleanup.

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

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

The intended use is clear: close a session to release its model and data, with the warning that the session_id becomes invalid immediately. It does not explicitly name an alternative or exclusion, but the object and effect are unambiguous enough to guide selection among siblings.

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 already cover idempotency and non-destructiveness; the description adds the behavioral detail that playback is paused and state remains loaded. It aligns with annotations and adds value beyond them.

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 that front-loads the main action and packs the two key behavioral consequences (pause playback, keep state loaded) 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 simple one-parameter, non-destructive, idempotent operation with an output schema, the description covers the essential behavior. It omits edge cases such as closing a viewer that is already closed, but the complexity is low and annotations cover the safety 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%, so the description must compensate for the undocumented session_id parameter. It only implies the session via 'this session's window' and does not explain what session_id is, where to obtain it, or any format constraints.

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

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

The description states a precise action — closing the current session's window — and immediately differentiates it from closing the whole session by noting the state stays loaded. It also clarifies 'pause playback', which leaves no ambiguity about what closing the viewer 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 phrase 'keeping its state loaded' signals when to prefer this over the sibling mujoco_close_session, giving clear context without naming the alternative explicitly. There is no explicit when-not-to-use guidance, 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?

The description richly supplements the annotations by explaining that noise affects observations only, physical state and force guarding remain raw, missing options return to defaults, and metadata is not policy-enforced. It also clarifies the destructive reset action implied by destructiveHint: true. No contradiction with annotations exists.

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 dense but efficient, with the core purpose front-loaded and every subsequent sentence adding operational or behavioral value. It avoids repetition and gets an extreme amount of useful information into a compact space.

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, the description covers preconditions (close viewer), all major configurable categories, noise behavior, idempotence, defaults, and metadata semantics. An output schema exists, so return-value documentation is not a gap. This is complete enough for an agent to invoke 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 description adds substantial meaning beyond the schema: units for joint offsets and noise (rad/m), mocap poses in meters and wxyz quaternions, ctrl_bias in actuator input units, and sensor noise in sensor-specific units. It also defines the semantics of key config fields such as metadata, force guarding, and reproducibility, which the raw schema alone 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 opens with a specific verb-resource pair: 'Configure generic trial conditions and reset to the realized seeded start.' This clearly distinguishes the tool from siblings like mujoco_reset or mujoco_set_state, since it both configures and resets in one operation.

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 concrete operational guidance such as 'Close viewer first', explains when options are omitted ('Missing options return to model defaults'), and clarifies that repeated configs reproduce initial conditions. It does not explicitly name alternative tools or state when not to use it, 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 already declare readOnly=true, idempotent=true, and destructive=false, so the safety profile is covered. The description adds valuable context: 'Source label is always sim' and clarifies that caller tags are metadata only, explaining what data is meaningful. It also enumerates the returned fields, giving the agent expectations beyond the annotation.

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 functionality. The additional sentences about source label and caller tags are directly relevant and not padding. Every sentence earns its place with no redundancy 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?

Given the existence of an output schema (which likely documents the return values), the description sufficiently summarizes the output content and nuances like source label and tag handling. However, the missing documentation of the session_id parameter leaves a minor gap in completeness, as the agent may not know how to construct a valid request without external context.

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

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

The description does not mention the session_id parameter at all, and the schema provides no description (coverage 0%). The agent must infer that session_id refers to the simulation session from context clues, but the description fails to explicitly define its role or format, which is a significant gap for a required parameter.

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

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

The description states exactly what the tool returns: 'compiled-model SHA-256, engine/server versions, code hash and experiment config.' This clearly identifies the resource and action, and distinguishes it from sibling tools like get_state or model_info, which serve 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 for retrieving provenance of a compiled simulation, clearly differentiating it from state or control tools. However, it does not explicitly name alternatives or conditions for when not to use it, so it falls short of a 5 but provides clear context.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context beyond that: values are unrounded, internal counters and guard status are included, and the snapshot must be taken while paused. There is no contradiction with annotations.

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

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

Four short sentences, each earning its place: the first front-loads scope, the second enumerates contents, and the last two give capture/storage guidance. There is no filler or redundant restatement of 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?

The output schema covers return shape, the annotations cover safety, and the description covers content, precision, and the need to pause. For a one-parameter snapshot tool, this is enough for an agent to invoke it correctly without missing critical context.

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

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

Schema description coverage is 0%, and the description never mentions session_id or explains how to obtain it. With low coverage, the description was expected to compensate for the parameter semantics, and it does not. The single self-explanatory 'Session Id' property limits the practical harm, but the gap 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 names a precise verb and resource: 'Get unrounded mjSTATE_INTEGRATION plus step/noise counters and guard status.' It also distinguishes itself from the sibling get_state-like tools by saying the snapshot goes 'beyond qpos/qvel.' An agent can tell exactly what this tool returns without opening the output 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?

The description gives clear capture context: persist the JSON and pause before capture, which tells an agent when snapshotting is valid. It does not explicitly name alternatives like mujoco_get_state or mujoco_restore_snapshot, so the when-not-to-use guidance is mostly 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds substantial behavioral context beyond these: it specifies the return format (JSON blocks), the cap of 20 contacts, world-frame coordinates for bodies, and the exact shape of sensor/body/contact data. This goes well beyond what annotations provide.

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, dense sentence that front-loads the core purpose and then enumerates output blocks. Every clause carries useful information—no filler, no repetition of schema content. It is concise yet comprehensive.

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 read-only, idempotent nature (covered by annotations) and the detailed description of all possible return blocks, limits, and coordinate frames, the description covers everything an agent needs to call the tool correctly. It also notes the contact cap, addressing potential data volume concerns. No critical information 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 covers 67% of parameters with descriptions (include and precision). The description indirectly clarifies the 'include' parameter by detailing what each block (qpos, qvel, ctrl, sensors, bodies, contacts) returns, helping the agent choose values. However, it does not add explicit syntax or format details for the parameters themselves, so it does not fully exceed the baseline for high schema coverage.

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

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

The description clearly states a specific action ('Read the current state of a session') and explicitly notes it does not advance physics, distinguishing it from step or set_state tools. It also lists the exact data blocks returned, leaving no ambiguity about the tool's function.

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

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

The phrase 'without advancing physics' provides clear context for when to use this tool (inspection rather than simulation advancement) but does not explicitly name alternatives or state when not to use it. The guidance is implicit rather than explicit, so it falls just 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 already establish read-only, idempotent, and non-destructive behavior. The description goes well beyond that by disclosing world-axis units, torque origin, the sum-of-magnitudes behavior that prevents cancellation, and the distinction between noisy observed force and unchanged raw force/guard.

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 primary purpose, followed by only high-value behavioral details. Every sentence contributes either scope, units, axis conventions, or noise behavior, with no redundant repetition of the title or annotations.

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 read-only measurement tool, the description covers scope, units, coordinate frames, torque reference point, sum semantics, and noise behavior. The output schema exists and can carry return-value field details, so the description is sufficiently complete for an agent to decide when and how to invoke the tool.

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

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

The input schema has no descriptions, so the description must compensate. It adds real meaning to body_name: the requested body must be non-world, and torque is about its origin. However, session_id is left entirely implicit, so one of the two required parameters still lacks explicit semantic 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 uses a specific verb-resource pair: 'Measure ALL external contacts on a non-world body and its descendants.' It clearly defines the scope of the measurement and explicitly contrasts itself with a general wrist F/T sensor, making it easy to distinguish from sibling state and model 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: use it to measure external contact wrenches, and explicitly warns that it is contact-only, not a general wrist F/T sensor. It does not name alternative sibling tools for the 'when not to use' case, so it stops just short of fully explicit routing.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds the 'active-only' scope and the response shape, but the response shape is presumably covered by the output schema, so the incremental behavioral disclosure is modest.

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

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

The description is two short sentences with the core purpose front-loaded and the response shape immediately following. There is no filler, restatement of the schema, 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 zero-parameter read-only listing tool, the description is nearly complete: it states the scope and response format, and annotations cover side-effect safety. However, it does not define what makes a session 'active' or mention any prerequisites, which would make it 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?

The tool has zero parameters, so there are no parameter semantics to explain. The baseline of 4 applies because the description does not need to compensate for any undocumented 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 uses a specific verb ('List') and a well-scoped resource ('all active simulation sessions'). No sibling tool performs this exact operation, so an agent can distinguish it immediately from state getters, snapshots, and session controls.

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

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

The purpose statement implies when to call it—whenever the agent needs to enumerate active sessions—but it gives no explicit guidance, exclusions, or alternatives. It does not say, for example, when to use get_snapshot or close_session instead.

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 annotations are uninformative; the description carries the burden. It discloses the new-session side effect, the exclusive-input requirement, the full JSON return shape, and the crucial fact that the returned name arrays define qpos/qvel/ctrl ordering for all other tools. It does not discuss failure/validation behavior or repeated-call consequences, but the provided behavioral context is strong.

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?

Every sentence earns its place: core action, input constraint, return contract, ordering implication, and next-step routing. It is front-loaded with the core purpose and keeps the detail compact.

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 for an agent to call the tool successfully: it states what to provide, what comes back, how to interpret the returned arrays, and which tools to use next. The richer return details also compensate for any ambiguity in the schema-only view.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description adds the essential constraint "exactly ONE of sample | file_path | xml_string," which is not captured by the optional/required schema fields. It also explains the downstream meaning of the returned names in terms of vector ordering.

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 clear verb and resource: "Load a MuJoCo model into a new simulation session." The phrase "new simulation session" distinguishes this from state-restoration and inspection siblings, and the explicit source options add operational precision.

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 contextual guidance: use it to create a new session, and exactly one of sample, file_path, or xml_string must be supplied. It also routes the agent to subsequent tools. It does not explicitly say when to prefer this over mujoco_restore_snapshot, but the "new simulation session" wording covers the main distinction.

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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the output JSON structure and usage advice, which is helpful but does not go beyond what annotations already establish. It does not contradict the annotations.

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

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

The description is concise: a one-line summary followed by the JSON return structure. It is front-loaded with the purpose and the detailed structure is useful for an info tool. No waste, though the JSON block is somewhat lengthy but necessary for clarity.

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

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

For a single-parameter tool with an output schema, the description provides a complete JSON structure in text, covering all returned fields. It also gives usage context. The tool is simple and the description is sufficient for an agent to call it correctly and interpret 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?

The only parameter is session_id, which is self-explanatory from its name and type (string). Schema coverage is 0%, but the description does not elaborate on session_id, nor does it need to given its simplicity. The baseline of 3 applies because the parameter is trivial and the name 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 it provides detailed structure of a loaded model, listing joint types/ranges, actuator ctrlranges, sensors, bodies, and options. This verb+resource combination is specific and distinguishes it from siblings like mujoco_get_state (which deals with state values) and mujoco_step (simulation). The annotation title 'Inspect model structure' reinforces the 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 gives explicit usage context: 'Use before choosing ctrl values (respect ctrlrange) or interpreting qpos/qvel layout.' This tells the agent when to call this tool, but it does not explicitly mention alternatives or exclusions. However, the intended use case is clear, and the read-only nature is implied by the tool type.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the window starts paused, there is a one-window-per-server constraint, and it does not attach to the standalone app. It also mentions macOS launch requirements. This goes beyond the annotations without contradicting them.

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: the core purpose is in the first sentence, followed by essential usage constraints and platform notes. Every sentence earns its place, and there is no fluff.

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

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

The tool has a simple input schema (one required parameter) and an output schema exists, so the description doesn't need to explain return values. The description covers the key behavioral constraints (paused start, one-window limit, standalone app distinction, macOS launch). It could explicitly state that session_id is the session to open, but the overall context is sufficient for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter session_id. The description mentions 'this session's model and state' but does not explicitly explain that session_id identifies which session's model/state to display. However, with only one parameter and a clear name, the meaning is largely inferable. The description adds some context but not a full parameter explanation.

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 ('Open') and resource ('native MuJoCo window sharing this session's model and state'), and distinguishes it from the standalone DMG app. It clearly identifies what the tool does and is distinct from siblings like mujoco_close_viewer.

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 explicit when-to-use guidance: 'Starts paused; call mujoco_step or mujoco_set_running next' and 'One window per server: close the current viewer before displaying another session.' It also tells the user what not to do ('does not attach to the standalone DMG app') and gives platform-specific launch instructions. This is strong 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?

Beyond the idempotentHint annotation, the description adds meaningful behavior: it zeros the step counter, clears force guard/runtime errors, restores the seeded start when present, and promises deterministic trajectory reproduction. It also states the return contract (same shape as mujoco_get_state). No contradiction with readOnlyHint=false or destructiveHint=false.

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, front-loaded with the core action, and every sentence contributes behavior or return information. No filler or restatement of 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 reset operation with an output schema and clear annotations, the description covers side effects, determinism, keyframe behavior, and return shape. The main gap is the lack of explicit guidance on when reset should be preferred over snapshot restore or set_state, but this is not essential to invoking it correctly.

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

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

Schema coverage is 67%, and the description adds value by specifying what happens without a keyframe (configured seeded start vs model defaults) and clarifying keyframe selection. Precision and session_id are already adequately documented in the schema, so the description need not repeat them.

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

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

The opening sentence names a specific action and resource ('Reset a session to its initial state (or a named keyframe) and zero the step counter'). This clearly differentiates it from siblings like mujoco_set_state or mujoco_restore_snapshot, which restore arbitrary or previously captured states rather than the session's initial/keyframe state.

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

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

The description explains the behavior for keyframe vs no-keyframe calls, which implies when reset is useful, but it never explicitly says when to choose reset over restore_snapshot, set_state, or configure_experiment. No alternatives or exclusions are named, so the guidance 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?

Annotations already declare destructiveHint=true and idempotentHint=true, and the description adds meaningful behavioral context: it restores exact integration state, step/noise counters, and guard status, and explains how the guard latch behaves across force-stop vs tripped snapshots. This goes beyond the annotations and helps the agent predict side effects.

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

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

The description is compact and front-loaded: the first sentence states the core action and precondition, and the second adds the most important behavioral nuance about guard latch behavior. Every sentence earns its place 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?

Given the tool's complexity (a restore operation with a nested snapshot object, no output schema, and destructive annotations), the description covers the critical preconditions and behavioral consequences. It could be more complete by explaining what happens to the current session state or whether the session must be paused vs. any state, but the essential information for safe invocation 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%, so the description must compensate, but it only explains the snapshot's role at a high level ('restores exact integration state, step/noise counters and guard status') and does not explain session_id semantics or the snapshot fields' meaning. The schema itself is fairly rich with field names and types, so the baseline is 3, but the description adds little parameter-level detail.

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 ('Restore') and resource ('a paused session'), and adds the key precondition that the compiled model, config, and engine version must be identical. It distinguishes itself from siblings like mujoco_get_snapshot and mujoco_set_state by focusing on restoring a full snapshot into a paused session, though it doesn't explicitly name a sibling 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?

The description clearly implies when to use this tool: when a session is paused and a snapshot exists, and it warns that the model/config/engine must match. It does not explicitly state when not to use it or name alternatives, but the precondition and 'paused session' context provide solid 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?

Beyond the annotations (readOnlyHint false, idempotentHint true), the description discloses that ctrl changes persist, playback can be updated live, closing the window or resetting pauses playback, and instability auto-pauses with recovery via mujoco_reset. No contradiction with annotations; it adds substantial behavioral 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 a compact paragraph with a front-loaded purpose, followed by tightly packed behavioral notes. Every sentence adds unique, non-redundant information without fluff, making it 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?

Given the tool's complexity (play/pause with live ctrl updates and error recovery), the description covers prerequisites, timing, side effects, and recovery. It even references the output mechanism (runtime_error) and pairs with an output schema, so return details are not needed here. No critical usage context 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 coverage is only 33% (only ctrl has a description). The description does not explicitly explain running or session_id, though running is implied by 'play/pause' and session_id is a standard identifier. It adds value for ctrl by noting persistence, but fails to fully compensate for the low schema coverage on the other two 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 'Play/pause the visible session at approximately real-time speed,' specifying the action and resource. It distinguishes itself from siblings like mujoco_step (single-step) and mujoco_reset (recovery) by focusing on the play/pause control of the viewer session.

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?

Provides a prerequisite ('Open a viewer first') and a key usage condition ('Pause before deterministic mujoco_step calls'), and explicitly routes to mujoco_reset for recovery from instability. It doesn't explicitly enumerate all alternative tools, but the context given is actionable and sufficient for common scenarios.

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

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

Beyond the annotations, the description discloses critical mechanics: only provided fields change, mj_forward runs so derived quantities update, time does not advance, and the resulting state JSON is returned. The idempotentHint and non-destructive annotations are consistent with the description, and the partial-update detail is valuable.

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 then adds compact, high-value behavioral and usage notes. Every sentence earns its place; there is no repeated schema content 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 an output schema present, the return shape is already covered. The description supplies the remaining context an agent needs: how the state overwrite behaves, how derived quantities are recomputed, why time is unaffected, and when to prefer snapshots instead.

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 high at 83% and the parameter descriptions are already detailed. The description adds the crucial partial-update semantic ('Only provided fields change') and hints at precision behavior with 'rounded state views.' It doesn't elaborate on session_id, but that parameter is self-evident.

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: 'Overwrite parts of a session's state' with qpos, qvel, ctrl, and time listed. It also differentiates from the snapshot-restore sibling by noting that snapshots, not rounded state views, should be used for exact continuation.

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 says this is 'useful for setting initial conditions or visual replay' and gives a clear when-not instruction: 'Use snapshots, not rounded state views, for exact continuation.' This routes the agent away from an inappropriate use case and toward the sibling restore_snapshot behavior.

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 only four all-false hints in the annotations, the description carries the behavioral burden and delivers: ctrl persistence across subsequent steps, the error-and-suggest behavior ("suggests mujoco_reset if the state diverges"), and the performance characteristic of batching. This is meaningful context beyond the structured annotation fields.

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?

Four dense sentences with zero filler: the first states the core action, the second the persistence trait, the third the return shape, and the fourth batching plus error recovery. The strongest detail is front-loaded, and every sentence 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?

An output schema exists, so return-format details are mostly handled externally, and the description covers the key call patterns (optional ctrl, batched nsteps, include filtering, divergence recovery). The main omission is the relationship to mujoco_step_guarded, which keeps this 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 coverage is 80%, so the schema already documents most parameters. The description adds real interpretive value for nsteps (batching to reach a 1s simulation) and include (filtering the returned state), but ctrl persistence is already stated in the schema, and precision is left for the schema to carry. Net addition is modest, matching the baseline.

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?

"Advance the simulation" is a crisp verb+resource statement, and the description further scopes the tool by noting optional control-setting plus the returned state. However, it never distinguishes itself from the near-identical sibling mujoco_step_guarded, so an agent must infer the difference from the name alone.

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 in-tool guidance ("Batch steps in one call... instead of many single-step calls") with a worked example tying nsteps to simulated time. But it does not explicitly say when to choose this tool over alternatives such as mujoco_step_guarded or mujoco_set_state, leaving tool-selection guidance 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?

The description discloses critical behavioral nuances beyond the annotations: the guard cannot guarantee zero overshoot, no safety certification, latching until reset/restore, sampling behavior (record_every, max 2000 frames), and that peak_force_N tracks all steps not just samples. These details are not in the annotations and are essential for correct usage.

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 dense but well-structured, front-loading the core action and guard behavior. Each sentence adds unique value (overshoot, latching, sampling, persistence). It is longer than minimal but not verbose; the structure keeps the most important behavior first.

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 (force guard, sampling, latching) and the presence of an output schema, the description covers all essential usage aspects: when it stops, what peak_force_N means, trip latching, sampling details, and persistence guidance. Nothing an agent needs to invoke it correctly 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?

With schema description coverage at only 17%, the description compensates by explaining the meaning of record_every (sampling trace, max 2000 frames), ctrl persistence, and the semantics of peak_force_N (summed contact load, no cancellation). However, it does not elaborate on nsteps or force_limit beyond what titles imply, and there is a minor discrepancy (schema max 10000 for record_every vs description's 2000) that could confuse.

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: 'Advance a paused session, measuring all contacts after every physics step' and specifies the stopping condition ('Stops at the first force-limit exceedance'). It distinguishes itself from the sibling mujoco_step by adding the force guard, making the verb+resource+differentiator 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 context (advancing a paused session, guard behavior) but does not explicitly compare with alternatives like mujoco_step or state when the unguarded version is preferable. The existence of a sibling tool is implied but not referenced, so an agent must infer the differentiation.

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