Skip to main content
Glama

batch

Destructive

Run multiple Roblox Studio operations in one round-trip and one undo entry, mixing different actions and returning per-operation results; halt on first failure when needed.

Instructions

Run MANY operations in ONE round-trip and ONE undo entry. The single biggest speed win for multi-step builds (a 40-instance UI = 1 call, not 40). Each op is { op, args } where args is exactly what that tool takes (omit place). Returns a per-op result list. Set stopOnError to halt at the first failure. Supported ops: create_instance, delete_instance, clone_instance, move_instance, rename_instance, mass_create, mass_duplicate, create_tree, set_property, mass_set_property, mass_edit, set_attribute, mass_set_attribute, add_tag, remove_tag, set_script_source, edit_script_lines, find_and_replace_in_scripts, set_selection, get_properties, get_children, get_script_source. (create_tree / mass_* already batch one kind; use batch to mix different ops.)

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "ops": "<ops>"
    },
    "name": "batch"
  }
}

Input Schema

NameRequiredDescriptionDefault
opsYesordered list of operations
placeNoTarget place (PlaceId or project name). Defaults to the bound/sole connected place.
stopOnErrorNohalt at first failure (default false)

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.5/5.0
Behavior4/5

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

Annotations already declare destructive=true, non-idempotent, closed-world; the description adds real substance on top: single undo entry, per-op result list, and the halting behavior of stopOnError. It stops short of stating what happens to already-applied ops when stopOnError fires (i.e., that the batch is not atomic and partial mutations persist inside one undo step), which is the main behavioral risk for a destructive multi-op tool.

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

Conciseness4/5

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

The lead sentence front-loads purpose and payoff before any mechanics, and every clause carries information. The long ops enumeration is dense but justified because the schema provides no enum for `op`; only the repeated schema-level details (`stopOnError` semantics) come close to redundancy.

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

Completeness4/5

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

For a destructive, non-idempotent meta-tool with no output schema, the definition is nearly complete: it discloses the return shape (per-op result list), the undo granularity, and error policy. The gap is failure semantics — whether a mid-batch failure leaves prior ops applied — which matters most for a tool that mutates state.

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

Parameters4/5

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

Schema coverage is 100%, so baseline is 3, but the description adds genuine meaning beyond the schema: the `op` field has no enum, and the definition supplies the complete closed list of 22 valid op names, which the schema does not. It also clarifies `args` is "exactly what that tool takes (omit `place`)" — the constraint that trip up callers since place lives at the top level.

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

Purpose5/5

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

"Run MANY operations in ONE round-trip and ONE undo entry" states a specific verb, the resource (a list of ops), and the two concrete benefits (latency, undo granularity). It then explicitly distinguishes itself from siblings that batch a single kind of operation: "create_tree / mass_* already batch one kind; use `batch` to mix different ops."

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

Usage Guidelines5/5

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

Gives an explicit when-to-use with a quantified example ("a 40-instance UI = 1 call, not 40") plus an explicit when-not-to-use, routing single-kind batching to create_tree / mass_*. The stopOnError instruction covers a usage decision an agent must make before invoking.

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