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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It explains error handling (stops on first error unless continueOnError is true), the inverse alias (stopOnError), the nesting restriction, and the undo waypoint behavior. It could mention return-value details, but the core behaviors are well covered.

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

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

The description is extremely concise—two sentences covering purpose, structure, error behavior, and usage guidance. It is front-loaded with the main purpose and contains no unnecessary words.

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

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

Given the tool's complexity (executing multiple arbitrary sub-tools) and the absence of an output schema, the description should explain what the return payload looks like (e.g., per-command results, error reporting). It does not, and it also does not specify whether partial mutations are rolled back on error. The description covers behavior well but leaves these important details 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 75%, covering commands, waypoint, and stopOnError. The description adds value by clarifying the alias relationship between stopOnError and continueOnError and confirming the command shape. However, continueOnError itself lacks a schema description, and the description does not elaborate further on parameter formatting beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: running several RoBridge tool calls in one request as a single undo waypoint. It uses a specific verb ('Run') and resource ('RoBridge tool calls'), and distinguishes itself from sibling tools like execute_luau by highlighting the batching aspect.

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 usage guidance by recommending this tool 'over many round-trips for related mutations' and explicitly rejecting nested batch_execute. It does not name specific alternative tools, but the context of batching vs. individual calls is clear.

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 delivers: it discloses security level, Edit-only constraint, return-value JSON encoding behavior (Instances become path strings, Roblox types become typed tables), and the RB helper table with its methods. This is rich behavioral context beyond any structured metadata.

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: purpose, usage guidance, return semantics, and helper table. It is front-loaded with the primary action, and the length is appropriate for the complexity of the tool. No fluff or repetition of schema details.

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

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

Given the tool's power (arbitrary code execution), the description covers all critical aspects: environment, security, Play vs Edit, return value handling, and available helper APIs. It even provides enough context for an agent to understand side-effect potential and encoding without needing an output schema. This is a model description for a code execution 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?

Although the schema covers both parameters at 100%, the description adds substantial meaning: the `code` parameter is elaborated with return-value behavior and RB helper context, which directly informs how to write the Luau code. Timeout is already adequately described in the schema, but the description's added context for `code` goes well beyond the basic schema description.

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

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

The description opens with 'Run arbitrary Luau code in Roblox Studio' — a clear specific verb+resource pair. It also distinguishes from siblings by noting 'plugin security level, Edit-only' and explicitly contrasting with Play-time alternatives, leaving no ambiguity about what this tool does.

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

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

Explicitly states when NOT to use this tool: 'During Play use manage_studio.run_test / play agents instead — plugin loadstring is unavailable in Play.' This provides a clear usage boundary and names the alternative tools, making the decision framework unambiguous.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds useful semantics (create must not invent IDs, load does not play, get_tracks returns tracks on a rig), but it does not describe effects of stop/stop_all, required prerequisites, or return behavior, leaving significant gaps.

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

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

The description is two compact sentences with a clear, inline action list. It front-loads the key caveat about animation IDs and avoids wasted words, achieving high density of useful information.

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

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

For a 6-parameter, multi-action tool with no annotations and no output schema, the description is too thin. It doesn't clarify which parameters each action requires, what stop_all affects (global vs. per-rig), or what each action returns, making it incomplete for an agent to invoke correctly in all cases.

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%, so the description must compensate. It adds context for animationId (do not invent), implies rigPath via 'load onto a rig', and clarifies get_tracks is rig-based, but leaves name, parentPath, and the precise semantics of path only partially covered.

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 explicitly names the resource (animations) and enumerates seven concrete actions (create, list, load, play, stop, stop_all, get_tracks), making the tool's purpose specific and distinguishing it from sibling tools like manage_audio or manage_camera.

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

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

There is no explicit guidance on when to use this tool versus alternatives, but the action list and resource name make the primary use case clear. The note about preferring user-provided or search-accepted animation IDs is helpful, but no exclusions or sibling alternatives are mentioned.

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

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

With no annotations provided, the description carries the full burden and meets it well. It discloses important behaviors such as the confirm=true requirement for upload_asset, the access dependency for generate_model, file-serialization side effects for export actions, and the local ./asset-library destination. This goes beyond the schema and gives the agent essential context about side effects and prerequisites.

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

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

The description is a single dense paragraph, but it front-loads the most critical rule ('ALWAYS search first') and packs actions efficiently with parenthetical specifics. It could be more scannable as a bullet list, but for 27 parameters it remains appropriately sized and avoids 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?

Given the tool's high complexity (27 parameters, no output schema, no annotations), the description covers all action types with enough context to guide invocation. It doesn't explain return values or error cases, but the action list plus schema coverage makes the tool usable. A more detailed walkthrough for each action would push it to 5, but this is solid.

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

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

The input schema already covers 96% of parameter descriptions, so the baseline is 3. The description adds value by mapping parameters to specific actions (e.g., 'search (keyword/query + assetType)', 'insert (assetId into parentPath)') and highlighting critical flags like confirm=true. While the description doesn't explain every alias or default, the schema already handles that 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 clearly identifies the tool as managing Roblox Toolbox/Creator Store assets plus a local asset library, and enumerates every action with specific verbs and resource targets. This distinguishes it from sibling tools that handle terrain, scripts, or instances.

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

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

The description provides a strong usage rule: 'ALWAYS search first, then insert using an assetId from those results — never invent or hardcode IDs.' It also outlines the workflow for each action. However, it doesn't explicitly contrast with nearby sibling tools like manage_audio or manage_selection, though the asset-specific context makes such exclusions less necessary.

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 burden. It adds behavioral context by specifying valid sound ID formats and the listener type options for set_listener. However, it does not disclose side effects of actions (e.g., whether stop_all affects all sounds globally, whether create is reversible, or what errors occur for invalid IDs). The action names imply some behavior, but deeper consequences remain undocumented.

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

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

A single sentence front-loads the purpose ('Manage Sound instances') and then efficiently enumerates actions and key constraints. There is no wasted wording; every clause adds useful information. The semicolon-separated structure keeps it compact while covering a broad action set.

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

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

Despite listing actions and some constraints, the description omits critical context for a tool with 9 parameters and no output schema. The 'set' action is undefined (what properties can be set?), the return values for 'list', the behavior of 'path' vs 'parentPath', and the format of the free-form 'properties' object are unexplained. The description is too skeletal for an agent to use every action correctly without further inference or trial-and-error.

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%, and the description does add meaning for some parameters: it clarifies that soundId can be a number or 'rbxassetid://...' and describes listenerType values. Yet many parameters like name, path, parentPath, properties, and cframe are not explained in the description beyond the schema, leaving significant gaps. The description partially compensates but not enough for a 9-parameter tool with low schema coverage.

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

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

The description clearly states the resource ('Sound instances') and provides a comprehensive verb-based list of actions (create, play, pause, resume, stop, stop_all, list, set, set_listener). This distinguishes it from sibling tools that operate on other resource types such as terrain, lighting, or physics.

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 specific usage constraints: 'do not invent IDs' and 'Prefer user-provided or search-accepted asset IDs' for the create action. It also lists all possible actions, making it clear when to use this tool. However, it does not explicitly mention when not to use it or describe alternatives like mutate_instances, so it falls short of an explicit exclusion 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?

With no annotations provided, the description carries the full transparency burden, and it excels. It discloses the CaptureService limitation (only one in-flight shot, ~1.5–2 fps caps), the fact that 'suggest' does not move the camera, that 'screenshot' works even when Studio is in the background, and the required security setting. These behavioral traits go well beyond the schema and give the agent critical operational expectations.

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

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

The description is tightly packed with essential information and is well-structured. It starts with the core purpose, lists actions in a compact syntax-heavy way, then adds necessary caveats and requirements. No verbose or redundant sentences; every clause adds value.

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

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

Given the tool's multi-action complexity and lack of output schema, the description is remarkably complete. It covers all actions, the CaptureService constraints, the security prerequisite, and the difference between similar actions (focus vs focus_position vs suggest). The only minor gap is that it doesn't explicitly describe return values (e.g., what 'get/info' returns), but for a control tool this is less critical.

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 88%, so most parameters are already documented. The description adds extra meaning beyond the schema by clarifying action-specific parameter semantics: 'focus_position (look at a world point)' and 'suggest (recommended views for a target or the selection — does not move the camera)'. It also explains the meaning of 'maxDimension' and 'fps' in context of CaptureService limitations, connecting parameters to real-world behavior.

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

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

The description opens with a clear verb+resource statement: 'Control the Studio viewport camera.' It then enumerates the full action list (get/info, set, focus, focus_path, focus_position, suggest, zoom_extents, screenshot, record, record_stop), distinguishing each action's role. This clearly separates it from sibling tools like manage_terrain or query_instances, which deal with other subsystems.

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 rich usage context: it explains when to use 'suggest' (for recommended views, does not move camera), that 'screenshot' works in background, and that 'record_stop' aborts in-flight recording. It also lists a prerequisite (File → Game Settings → Security → Allow Mesh / Image APIs), which guides the user on setup. However, it doesn't explicitly name alternative tools to use instead, relying on the tool name and sibling context for 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?

With no annotations, the description carries the full burden. It transparently lists actions like remove/clear and emit, indicating mutating behavior, but does not disclose side effects, permission requirements, or return format. This is a moderate disclosure for a potentially destructive tool.

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

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

The description is a single, information-dense sentence that front-loads the core purpose and then compactly lists actions and effect types. Every word contributes value with no redundancy.

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

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

The description provides a good overview but lacks details on the flexible 'properties' object and the 'name' parameter. It also does not explain output for actions like list, which is a gap given there is no output schema.

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

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

The description adds significant meaning to the action and effectType parameters by enumerating valid effect types and clarifying what emit and toggle do. However, it does not explain the 'properties' or 'name' parameters, so with only 33% schema coverage, some parameters remain under-documented.

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 'Add visual effects to parts' and enumerates specific effect types and actions, giving a precise scope. It does not explicitly distinguish it from sibling tools like manage_lighting, but the name and content make the purpose clear.

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

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

Usage is implied through the action list and effect types, but there is no explicit guidance on when to use this tool versus alternatives like manage_lighting or manage_scripts. It provides context but no exclusions or alternative recommendations.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals implementation details (UserInputService:CreateVirtualInput vs VirtualInputManager, LastClick attribute) and explains what each simulated action does. It stops short of describing error handling, return values, or 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 dense with information but structured as a single run-on sentence with many parentheticals and clauses. It is not poorly sized, but better formatting (e.g., bullets) would improve readability and scannability.

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 (10 parameters, 7 action types) and lack of output schema, the description covers the core behaviors and action distinctions well. It omits potential details like result values, failure modes, or whether input is simulated server-side or client-side, but the provided context is sufficient for basic use.

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

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

The description adds meaning beyond the schema by mapping parameters to actions (e.g., click_at uses viewport pixels, click_path targets a PlayerGui GuiButton, walk_to uses a path/position). Since schema coverage is only 50%, this helps fill gaps, though not all parameters (x, y, text, duration) are explicitly defined in the description.

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

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

The description opens with 'Simulate input,' a specific verb+resource phrase, and enumerates distinct action types (walk_to, click_world, etc.) that clearly differentiate it from sibling tools like manage_terrain or query_instances. The scope is unambiguous.

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

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

Provides concrete guidance for when to use specific actions (e.g., 'walk_and_click — use this to verify world clicks') and distinguishes playtest vs edit behavior for click_path. However, it does not explicitly contrast with sibling tools or state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It provides useful context: clockTime range (0-24), time format ('HH:MM:SS'), createIfMissing behavior, mood presets, and the warning 'Do not invent skybox asset IDs.' It clearly indicates read-write capabilities ('Inspect or change'). However, it does not disclose return values for 'get' nor potential side effects of mutations.

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 dense list of actions packed into a single long sentence. It is not elegantly structured but every action is briefly explained. It earns its place by covering many subcommands without excessive verbosity, though readability could be improved with line breaks or bullets.

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 8 parameters, nested objects, and no output schema. The description covers most action-parameter semantics, but there are gaps: what does 'get' return? How does 'set' differ from 'lighting'? What does 'sky' do beyond 'do not invent asset IDs'? The description is adequate for basic usage but incomplete for an AI agent that needs to understand exact behavior without examples.

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 only 50%, missing descriptions for action, clockTime, mood, and properties. The description compensates significantly by explaining how the action parameter maps to other params: 'set_time/time (clockTime 0-24 or time 'HH:MM:SS')', 'mood (preset: ... plus optional overrides)', and 'atmosphere (get/set Atmosphere, createIfMissing)'. This adds high value beyond the raw schema.

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

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

The description clearly states the tool's function: 'Inspect or change Lighting and environment.' It lists specific actions (get, set, set_time, atmosphere, sky, terrain_props, mood, add_effect, clear_effects) that cover the domain, distinguishing it from siblings like manage_terrain or manage_effects. The verb 'inspect/change' is specific and the resource is clearly defined.

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

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

The description does not explicitly state when to use this tool versus alternatives. It implies usage through its action list, but there are no exclusions or alternative tool references. For example, it doesn't clarify that terrain_props is for terrain visuals, which overlaps with manage_terrain. The only caution is 'Do not invent skybox asset IDs,' which is more of a constraint than a usage guideline.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It mentions the log source and the 'clear' action, but does not warn that 'clear' is destructive or explain any side effects of the read actions. Permissions, rate limits, or data retention are also not addressed.

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 main purpose and then lists actions in a compact structure. It avoids wasted words, though the packed list could be slightly more readable with line breaks.

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

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

The description covers the main actions and filters, but omits important context such as the default limit, return format, and the irreversibility of 'clear'. Given no output schema and no annotations, this leaves gaps for an agent to fully understand consequences and expected responses.

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

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

The schema already describes most parameters, but the description adds valuable semantics: it clarifies 'since' as a unix-seconds cursor, maps 'errors' to Error-level only, and labels levelFilter values. This goes beyond the raw schema and helps the agent use filters correctly.

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 reads the Roblox Studio output log and enumerates specific actions (get, errors, clear), making its purpose unambiguous. This distinguishes it from sibling tools like query_instances or execute_luau, which focus on other concerns.

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 clear context on log sources (plugin via LogService, play-mode from play agent) and describes each action's filter parameters. However, it does not explicitly state when to prefer this over alternatives or when not to use it, but the context is sufficient for typical use cases.

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 for behavioral disclosure. It lists action verbs but doesn't explain side effects (e.g., whether 'weld' permanently connects parts, whether 'anchor' affects physics simulation), reversibility, required permissions, or what gets destroyed or changed. The parenthetical about collision groups provides a tiny bit of context, but overall it's minimal.

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

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

The description is a single sentence listing actions, which is concise but under-structured. It front-loads 'Physics helpers' but then becomes a dense list. It's not overly verbose, but the lack of grouping or explanation makes it less effective than a brief structured overview.

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 (10 actions, 13 parameters, no output schema, no annotations), this description is severely incomplete. It provides no per-action behavior, expected return values, prerequisite conditions, or examples. The description is essentially a menu of action names without the context needed to select among them confidently.

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 only 8% (only 'group' has a description), so the description must compensate. It doesn't map actions to their relevant parameters. For example, 'create_constraint' likely requires 'constraintType' and 'otherPath', but this isn't stated. The list of actions adds no semantic detail beyond their names, leaving the agent to guess which of the 13 parameters apply.

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 says 'Physics helpers' and lists actions like 'anchor / unanchor, set_collide, weld', which conveys it's a physics manipulation tool. However, it lacks a clear statement of the tool's overall purpose or how it differs from sibling tools like manage_properties or execute_luau. The list of actions gives some clarity but is more of an enumeration than a coherent 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention scenarios that favor manage_physics over manage_properties, execute_luau, or other siblings. The parenthetical about PhysicsService collision groups is the only contextual hint, and it applies only to a subset of actions.

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

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

With no annotations provided, the description carries the full transparency burden. It explains behaviors of many actions (e.g., set_relative uses add/subtract/multiply/divide or plain delta; set_calculated evaluates expressions with variables; modify_children sets props on matching children). However, it does not disclose side effects (e.g., overwriting existing values), return formats, permissions, or error behavior, so transparency is partial.

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 long run-on sentence with a massive action list separated by commas and semicolons. It is not concisely structured; a bulleted list or shorter grouped summary would be easier for an agent to parse. While it is front-loaded with the main purpose, the dense enumeration hinders readability, making it less than minimally viable in this 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?

Given the tool's high complexity (16 parameters, 20+ actions, no output schema), the description is quite comprehensive. It covers all actions, highlights important aliases and parameter interactions, and explains nuanced behaviors for complex actions. It omits some details like return value structures or prerequisites, but overall it provides sufficient context for an agent to select and invoke the tool in many scenarios.

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 high (94%), so the baseline is 3. The description adds meaningful semantics beyond the schema by explaining action enum meanings (set_many/set_multiple equivalence, set with properties map, set_relative operation, set_calculated variables, mass_set/mass_get, modify_children). This clarifies how parameters like 'properties', 'operation', and 'variables' integrate with actions, adding value beyond the schema.

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

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

The description clearly states 'Get/set properties, attributes and tags', which identifies the specific resource and actions. It distinguishes the tool from broader siblings like mutate_instances or query_instances by focusing on properties/attributes/tags, and enumerates concrete actions. However, it does not explicitly name sibling alternatives, so it stops short of a 5.

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

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

Usage is implied by the resource focus: use this tool for properties, attributes, and tags. The action list gives some idea of when to choose specific actions (e.g., set_relative for math operations, set_calculated for expressions), but there is no explicit 'when to use vs. alternatives' guidance or exclusions for sibling tools. No alternatives are mentioned, so the guidance is implicit rather than explicit.

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

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

No annotations are provided, so the description must carry transparency. It adds useful semantic glosses: replace is 'substring across scripts,' edit_replace is 'find/replace in one script,' validate is a 'loadstring syntax check,' and get_dependencies lists 'require() targets and services.' However, it does not disclose side effects for destructive actions (create/delete/set_source), permission requirements, or return behavior, leaving meaningful behavioral ambiguity.

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

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

The description is a compact single paragraph that front-loads the target resource and action list without filler. Each parenthetical earns its place by disambiguating action names, and the usage note is delivered in one short sentence.

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 13-action tool with no output schema and no annotations, the description provides a useful action inventory but leaves gaps. It does not specify which parameters are required per action, explain the ambiguous 'edit_lines' action, describe return formats for validate/list/search, or note failure/side-effect behavior. The schema covers parameter names but not action-level contracts.

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

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

The input schema already describes most parameters (69% coverage), so the baseline is 3. The description adds action-to-parameter context beyond the schema: it clarifies replace vs. edit_replace scope, edit_insert/edit_delete line usage, validate input modes, and get_dependencies output semantics. This lifts parameter understanding above schema-only.

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 by naming the exact resource class (Script/LocalScript/ModuleScript sources) and enumerates thirteen concrete actions, making the tool's purpose unambiguous. It also distinguishes itself from sibling execute_luau via the phrase 'Prefer these over execute_luau for script edits.'

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 final sentence is an explicit usage directive: 'Prefer these over execute_luau for script edits.' This names an alternative and states when to choose this tool. Even though no other alternatives are mentioned, the core when-to-use guidance is clear and actionable.

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 non-obvious behaviors such as 'cached' avoiding a Studio round-trip and 'watch' requiring a second call to collect changes. It also hints at return structure (details, context). While it does not explicitly mention side effects of mutation actions, the action names (add/remove/clear/set) clearly imply selection modification, and the description adds meaningful context beyond the 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?

The description is front-loaded with the core purpose and then lists actions with parenthetical parameter and behavior notes. It is concise and avoids redundancy, though the single-sentence structure is dense and could be improved with a bulleted list. Still, every word earns its place.

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

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

For a tool with 9 actions and 8 parameters, the description covers all action variants and their parameter dependencies, including return semantics for details, cached, and context. It lacks explicit error handling or prerequisites, but given the complexity and absence of an output schema, it provides sufficient context for an agent to select and 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?

Schema coverage is 75%, with descriptions for maxAge, maxDepth, includeSource, includeChildren, includeAncestors, and includeProperties. The description adds meaning for the undocumented parameters: 'paths' is explicitly tied to the 'set' action, and 'action' is fully explained by the enumerated action list. It also associates each parameter with its relevant action, enhancing understanding beyond the schema.

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

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

The description clearly states the tool's purpose: 'Get or set the Studio selection.' It enumerates all supported actions (get, set, add, remove, clear, details, cached, context, watch), specifying the resource (selection) and distinguishing it from sibling instance management tools like query_instances or mutate_instances.

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 brief context for each action (e.g., 'cached' for last known selection without round-trip, 'watch' for installing a watcher), which helps the agent choose the right action. It does not explicitly contrast with sibling tools or mention when not to use this tool, but the selection-specific scope makes it the obvious choice for selection operations.

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

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

With no annotations, the description carries the transparency burden. It discloses important behaviors: run_test injects Luau, plays, collects [ROBRIDGE_TEST] logs, stops, writes report, and auto-records a clip unless record=false. It also notes test_profile_get/set/reset have no public API and return manual_required, and experience_language_set is manual_required. This is substantial, though some actions like undo/redo/save_prompt lack 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 dense and informative but delivered as a long run-on paragraph with a massive action list. It front-loads the purpose, but the list is hard to scan. Each piece of information earns its place, but the structure could be improved with line breaks or grouping for readability.

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 (17 actions, 14 params, no output schema), the description covers a lot: run_test workflow, special manual_required cases, viewport clip behavior, and playtest guidance. It does not describe return formats for simple actions like get_mode or play_status, but the core behavioral expectations are well documented.

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 86%, so the schema already documents most parameters. The description adds meaning beyond the schema by explaining action-specific semantics: 'mode: play (F5) or run (F8)', 'toggle_ui_preview (StarterGui.ShowDevelopmentGui)', and run_test behavior including record defaults and timeout context. This complements the schema effectively.

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 'Studio-level operations' and enumerates 17 distinct actions with specific verbs and targets (e.g., 'play_start', 'toggle_ui_preview', 'test_profile_get/set/reset'). This clearly differentiates the tool from sibling tools like manage_scripts or manage_camera. However, it is not a single specific action but a broad collection, which slightly reduces clarity.

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

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

The description provides explicit workflow guidance: 'After adding a player-facing feature... playtest with run_test or play_start before reporting done' and 'Prefer run_test over manually sequencing play_start + logs + play_stop.' It also names an alternative for viewport clips ('manage_camera.record, or run_test'), satisfying the when-to-use vs alternatives criterion.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It reveals key side effects: write_file 'apply[ies] it to the Studio script' and export_scripts 'dump[s]' files to disk. However, it does not mention overwrite behavior, permission requirements, or error conditions, leaving some behavioral ambiguity.

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

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

The description is a single dense sentence with a colon and semicolon-separated list. It is efficient, with no filler, and each action gets a brief parenthetical. However, it is somewhat run-on and could benefit from bullet points for easier scanning.

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

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

The tool has 7 parameters and 8 actions; the description covers all actions and hints at return values (e.g., 'place + sync dir + last export', 'last export stats'). It does not distinguish status from status_current_place, and with no output schema, exact return formats are only partially implied, but overall it is reasonably complete.

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

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

Schema description coverage is 86% (high), so the baseline is 3. The description adds significant value by explaining what each action parameter does (e.g., 'history (recent sync operations)', 'directions (get or set per-type sync directions)'), going beyond the bare schema descriptions and enum values.

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

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

The description clearly states the tool's purpose: 'Sync between Studio and the local filesystem.' It then enumerates all eight actions with specific explanations, making it easy to distinguish from siblings like manage_scripts (script management) and execute_luau (code execution).

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

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

The description implies usage through its opening phrase and details the behavior of each action (e.g., 'export_scripts' dumps scripts to disk, 'write_file' writes and applies to Studio). It does not explicitly name alternatives or exclusions, but the action list provides sufficient context for most use cases.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does include some detail (e.g., resolution is always 4 in Roblox, smooth uses blend strength), but it fails to mention whether actions are destructive/reversible, require permissions, or what read operations return. 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 structure is logical: purpose, action list, region format, material list. It front-loads 'Edit Terrain' and uses compact bullets/lists. While long, the content is dense and each section serves a purpose given the tool's many actions and materials.

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 27 parameters and 16 actions, but the description omits important context: no output format for read actions, no error/edge-case behavior, and no distinction between read-only and mutating actions. With no output schema or annotations, this leaves significant gaps for an agent to safely 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 description adds value by explaining action-specific parameter relationships, such as clear_region accepting either center+size or a region object, and replace_material using fromMaterial→material. These mappings go beyond the raw schema and help the agent select the right parameters for each action.

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 'Edit Terrain' and then enumerates all supported actions, which clearly establishes the tool's scope as terrain manipulation. However, it doesn't explicitly distinguish this from sibling tools that might also access terrain data (e.g., query_instances), and the long action list may obscure the core 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?

There is no guidance on when to use this tool versus alternatives. The description lists actions but doesn't explain which scenarios call for each action or when to prefer a sibling tool for related operations.

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 are provided, the description carries the full disclosure burden. It reveals that create does not play, that playback occurs live in the viewport, and that pause/resume/cancel can target individual or all tracked tweens. Missing details include error handling and state persistence, but the core behavioral traits are covered.

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

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

The description is dense but efficient, packing action semantics and parameter aliases into a single well-structured sentence. Every phrase adds value; no filler.

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

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

For an 11-parameter tool with no output schema and no annotations, the description gives a solid conceptual overview but omits detailed parameter semantics and return behavior (e.g., what play/pause return). The nested tweenInfo object is only hinted at via the example, making it less complete than ideal.

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 only 36% description coverage, and the description adds meaning for key fields (goal/properties alias, tweenId, action semantics). However, duration, tweenInfo, easing fields, and repeatCount remain undocumented, leaving a substantial gap for a low-coverage schema.

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

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

The description clearly states the tool's function—animating properties via TweenService—and differentiates it from sibling tools like manage_animation by specifying the live-viewport playback and action set. The verb 'Animate' plus resource 'TweenService' makes the purpose unambiguous.

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

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

The description provides explicit guidance on actions (create, play, pause, resume, cancel/stop_all) and explains when to use tweenId vs path+goal. It does not explicitly call out alternatives, but the context is clear enough for an agent to choose it for tweening tasks.

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

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

With no annotations, the description carries the full burden. It discloses important behavioral traits: preview clones into CoreGui in Edit, click uses VirtualInput/attribute click with specific contexts, scroll targets ScrollingFrame CanvasPosition, and design_brief can conditionally build via create=true. However, some actions like check/get_abs/delete are not elaborated regarding side effects or return behavior, leaving gaps.

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

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

The description is a single, dense sentence that front-loads the main purpose and then lists actions with parenthetical clarifications. It is concise and information-dense, but the one-sentence structure could be improved with bullet points for readability. Still, every word earns its place.

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

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

Given the tool's high complexity (13 params, many actions, nested trees, no output schema), the description covers the main action list and key operational contexts, which is substantial. However, it omits details on return values, prerequisites, and some actions (e.g., check, get_abs, update), so it is not fully complete.

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

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

Schema description coverage is only 38%, so the description adds meaning. It maps actions to parameters: design_brief uses 'brief' and 'create', preview/clicks/scroll explain PlayerGui/StarterGui context, and delta/canvasPosition are clarified. Yet several properties (path, parentPath, screenGuiName, depth, kind, properties, tree) are not described in the text, though some are self-explanatory.

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 'Create, inspect, preview, and interact with Roblox UI' with a specific verb+resource, clearly distinguishing it from sibling tools like manage_terrain or manage_lighting. It enumerates 14 concrete actions, leaving no ambiguity about the tool's scope.

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

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

The description implies it is the go-to tool for Roblox UI manipulation, and the action-specific notes (e.g., preview clones into CoreGui in Edit, click/scroll work in PlayerGui during playtest) give context on when each action applies. However, it does not explicitly state when to use it over alternatives like mutate_instances or query_instances, nor does it mention 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?

No annotations are provided, so the description alone must disclose behavior. It reveals the types of operations (including irreversible ones like delete) and accepted property value formats, but it does not warn about permanence, workspace impact, or permission requirements. This is a moderate level of transparency.

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

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

The description is a single run-on sentence combining a list of actions and a property-value guide. While all information is relevant, it lacks bullet points or sectioning, making it harder to parse. The core actions are front-loaded, but the mid-sentence 'Also:' list is dense.

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 high complexity (23 params, 13 sub-actions), the description is under-specified. It lists sub-action names but does not explain which parameters each sub-action requires (e.g., scatter needs templatePaths, region, count) or provide usage examples. The schema's param descriptions partially compensate, but the action-param mapping is left implicit.

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 important value-format semantics for the 'properties' parameter (Vector3, CFrame, Color3, UDim2, enums) which are absent from the schema's generic property object. It also redundantly lists the action enum values, which are already in the schema, but the property-format information significantly enhances parameter handling.

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

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

The description opens with a clear enumeration of mutation verbs ('Create, delete, clone, move, rename, or pivot instances'), explicitly establishing the tool's scope as structural mutation of instances. It further distinguishes from siblings like query_instances by focusing on mutation operations.

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

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

The description implies when to use the tool (when you need to mutate instances) but does not explicitly state alternatives or exclusions. The list of sub-operations (create_with_props, mass_create, scatter) gives context for specific actions, but no guidance on when to choose this over manage_properties or other tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explains path formats, aliases, and the rationale for rbId preference, but does not explicitly confirm the tool is read-only or describe result formatting/performance implications.

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 long but densely packed with necessary information for a tool with 20 parameters: action list, path syntax, alias map, and usage preference. It is front-loaded with the core purpose and avoids 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?

Given the tool's complexity (20 params, no output schema), the description covers actions, path formats, aliases, defaults, and usage guidance. It lacks examples but is otherwise comprehensive enough for an agent to select and invoke 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 95%, so baseline is 3. The description adds valuable context beyond the schema by explaining alias relationships and the rbId-over-path preference, which clarifies parameter usage.

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 'Query instances in the Roblox place' and lists 14 specific actions, making the tool's function clear and specific. It distinguishes itself from sibling tools like execute_luau and spatial_query.

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

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

Explicitly instructs 'Prefer a typed action over execute_luau' and provides guidance on using rbId over path because 'names like Part are not unique.' However, it does not detail when to use this tool versus spatial_query or manage_properties.

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

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

No annotations are provided, so the description must carry the burden. It discloses some behavioral details (e.g., max 50 rays, area format, parameter dependencies) but does not clarify which actions are read-only versus mutating (e.g., snap_grid appears to write) nor describe side effects or return structures.

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 packs a substantial amount of information into a single concise paragraph, front-loaded with the tool's purpose. Each action is listed with relevant parameters, and there is no redundancy. Readability could be improved with formatting, but it is efficient.

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

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

Given the tool's complexity and lack of output schema or annotations, the description is incomplete. It does not explain what any of the 16 actions return, leaving significant ambiguity for an agent. It also doesn't clarify potential write side effects for actions like snap_grid.

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?

While the schema covers 78% of parameters, the description adds crucial action-to-parameter mappings (e.g., 'raycast (filterList/filterType/ignoreWater)') that are absent from the schema. It also standardizes the area format and clarifies parameter alternatives (e.g., 'position or x/z').

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 explicitly states 'Spatial queries in workspace' and enumerates all supported actions, making the tool's purpose unmistakable. It distinguishes itself from sibling tools like query_instances and manage_terrain by focusing specifically on spatial operations.

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

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

The description implies usage: it lists actions and area formats, so an agent can infer when to use it. However, it does not explicitly state when to prefer this tool over siblings or provide any exclusion criteria.

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

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

Discloses the default behavior ('No action (or action=info) returns the full snapshot') and explicitly labels preflight as 'read-only'. Without annotations, this provides useful behavioral detail, though it does not uniformly state that all actions are read-only.

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

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

The description is a single well-structured sentence that front-loads the purpose, states the default behavior, and lists actions in a compact, scannable format. No word is wasted.

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

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

For a tool with one optional enum parameter and no annotations or output schema, the description adequately covers the purpose, all action variants, and the default snapshot behavior. It is complete enough for an agent to select and invoke correctly.

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

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

The schema only lists an enum with no descriptions, so the description fully compensates by explaining each action's meaning (e.g., 'usage (per-tool call statistics...)'). It also clarifies the optional nature and default behavior when the parameter is omitted.

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 'RoBridge + Studio status' and enumerates specific actions (ping, connection, place_info, etc.) that return status information. This distinguishes it from sibling tools that handle mutations or queries of specific game objects.

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 clear context for when to use each action (e.g., 'ping (latency)', 'preflight (read-only Studio diagnostics)'), but does not explicitly name alternatives or state when not to use the tool. The read-only nature and action list make the intended usage evident.

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

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

No annotations are provided, so the description carries the full burden. It discloses significant side effects: 'changes (recent added/removed instances — installs a watcher on first call)' and 'clear_cache (drop watchers and cached plugin state)'. These reveal non-obvious behaviors beyond the schema. It also clarifies the destructive nature of clear_history and clear_cache. The description could have been more explicit about read-only safety for other actions, but it does highlight the main side-effectful operations.

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 dense single paragraph with a two-word opening and a semicolon-separated action list. It is concise given the number of actions (11), and each action's description is brief and informative. It is not bulleted, but the structure is readable and each word contributes. It could be improved by using a list format, but it remains appropriately sized for the tool's 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?

With 11 actions, 8 parameters, no annotations, and no output schema, the description covers all actions with understandable summaries and highlights key side effects and parameter usage. It does not provide detailed return value formats, but given the absence of an output schema, this is acceptable. It also does not explicitly describe what 'summary' includes beyond 'place info, top-level services, selection, camera', or the behavior of 'topN', but overall it is sufficiently complete for an agent to select the right action.

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 meaning beyond the schema by mapping parameters to actions: 'counts (instance counts by ClassName under a path)' clarifies the path parameter, and 'snapshot (instance tree under a path, maxDepth)' links path and maxDepth. It also clarifies that includeMetadata relates to sync. However, the topN parameter is not described anywhere, and the schema already provides descriptions for limit, maxDepth, includeMetadata, includeCameraInfo, and includeSelectionBounds. The description adds value for path and action-parameter associations but leaves a gap.

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 defines the tool as a 'Snapshot of the place' and then enumerates eleven specific actions, each with a concise description of what it returns (e.g., 'counts (instance counts by ClassName under a path)', 'viewport (camera + viewport size + selection bounds)'). This provides specific verb-action-resource tuples and distinguishes it from sibling management/query tools by focusing on state introspection rather than mutation.

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?

Each action is described with its exact use case (e.g., 'sync (hierarchy outline + metadata + change stats)', 'scripts (all script paths with line counts)'), giving clear context for when to use a particular action. However, the description does not explicitly mention when to prefer this tool over sibling alternatives like query_instances or spatial_query, nor does it state exclusions. The guidance is implied by the action list.

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