Skip to main content
Glama

Copy, align and group

arrange
Destructive

Organize furniture and room elements using array, align, distribute, flip, rotate, mirror, group, and front/back operations, all undoable in one step.

Instructions

Arrange elements in one undo step. array {ids,n,dx,dy,dz} adds n copies stepping by dx/dy/dz cm (rafters, columns); align {ids,axis,edge:low|middle|high,value} lines pieces up by an edge — backs on one line, fronts on another — instead of by centers you work out yourself; distribute {ids,axis,gap?} sets them side by side in the order given, from where the first one is (a run of joinery); flip {ids} turns a piece back to front, rebuilding what is inside it (mirror only swaps left and right and leaves the front where it was); rotate {ids,angle clockwise,about?,copy?}; mirror {ids,a,b,copy?} across the line a-b; group {ids,name?} joins pieces into one box that moves/hides together, ungroup {ids:[group]}; front/back {ids} draws rooms or pieces on top/underneath (pool over deck, rug under sofa). Returns new ids.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
aNomirror: the first point of the mirror line
bNomirror: the second point of the mirror line
nNoarray: number of copies (default 1)
dxNoarray: step per copy along x, cm
dyNoarray: step per copy along y, cm
dzNoarray: step per copy upwards, cm (furniture and labels)
gapNodistribute: centimeters between one piece and the next (default 0)
idsYesThe elements to act on (ungroup: the group)
axisNoalign/distribute: `x` or `y`
copyNorotate/mirror: keep the originals and transform a copy
edgeNoalign: which edge to line up — `low` (left, or top of the plan), `middle`, `high`
nameNogroup: its name
aboutNorotate: pivot `[x,y]` (default the center of the elements)
angleNorotate: clockwise degrees
valueNoalign: the coordinate, cm, to put that edge on
actionYes`array` (copies in a row), `align`, `distribute`, `flip`, `rotate`, `mirror`, `group`, `ungroup`, `front`, `back`

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
vNoPlan version written to, when there are several
okYesAlways true
idsNoIds created or touched
revNoPlan revision
textYesThe reply as written

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.1/5.0
Behavior4/5

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutation risk is known. The description adds valuable behavioral details beyond that: 'flip' turns a piece back to front and 'rebuilds what is inside it', 'mirror only swaps left and right and leaves the front where it was', and each sub-action has specific side effects. It also discloses the return value ('Returns new ids'). This goes well beyond the basic annotations.

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 description is long (about 150 words) but packs a lot of information for a tool with 9 sub-actions and 16 parameters. It front-loads the overall purpose ('Arrange elements in one undo step') and then lists each action in a structured, semi-colon-separated format. No sentence is wasted, though the density requires careful reading. It could be slightly more concise by grouping, but it stays efficient.

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 tool this complex, the description covers each action's parameters and behavior, plus the return value. It does not cover edge cases or prerequisites (e.g., whether ids must be on the same level, coordinate system assumptions), but given the output schema exists and annotations cover safety, an agent can invoke it correctly for the listed scenarios. The main gap is a lack of examples or warnings about interactions between actions, but it is sufficient.

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 every parameter is already documented. The description adds meaning by explaining how parameters drive each action, e.g., 'array {ids,n,dx,dy,dz} adds n copies stepping by dx/dy/dz cm' and 'align {ids,axis,edge:low|middle|high,value} lines pieces up by an edge'. It clarifies the purpose of 'edge' values (low=middle=high) and 'value' as the target coordinate, which goes beyond the schema's terse field names.

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?

The description states a clear, multi-purpose resource: 'Arrange elements in one undo step' and enumerates each sub-action with its verb and resource ('array' copies pieces, 'align' lines up edges, 'distribute' sets them side by side, etc.). It explicitly distinguishes from sibling tools by detailing unique behaviors like 'flip' (turn a piece back to front) and 'front/back' (draw rooms on top/underneath), so an agent can select it without opening the schema.

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

Usage Guidelines3/5

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

The description explains what the tool does but not when to prefer it over alternatives. It never mentions sibling tools like 'move', 'place', or 'joinery' or gives conditions for using those instead. The atomic 'one undo step' hint is useful, but the guidance is implicit rather than explicit about alternative selection.

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