Skip to main content
Glama

live_api

Destructive

Access any Ableton Live object property or method not covered by other tools. Inspect, read, set or call song, view, device, clip and mixer members by path, returned as plain JSON.

Instructions

Escape hatch to Live's object model for anything the other tools do not cover: Song, view, device, clip or mixer properties and methods.

Start with info on the object to see its members, then get, set or call. Set and call need write=true, change one undo step, and say what Live holds after (Live silently keeps the old value for some invalid writes). Prefer the dedicated tools when one exists; they check more. Results are plain JSON: Live objects come back as {object, name, address}. Underscore names, modules and files are never reachable.

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": {
      "path": "<path>",
      "operation": "<operation>"
    },
    "name": "live_api"
  }
}

Input Schema

NameRequiredDescriptionDefault
argsNoFor call: the arguments in order. Example: [{"value": 4}, {"ref": "t0"}]
nameNoThe property or method. For info: only members containing this text.
pathYesThe object: song, app, or an address (t0, rA, m, t0/d1, t0/d0/c1/d0, t0/d0/pC1, s2 = scene, t0/s2 = clip slot, t0/a1 = Arrangement clip), then optional .member steps; a number indexes a list. Examples: song.view, t0.mixer_device.sends.1, t0/s2.clip, song.cue_points.0
limitNoFor info and list: items per page (default 100, at most 500).
valueNoFor set: the new value. ref:t0/d1 passes a Live object.
writeNoMust be true for set and call. Reads never need it.
offsetNoFor info and list: skip this many items.
confirmNoAlso needed to call a method starting with delete, remove, clear or stop_all.
operationYesinfo: members of the object. get: read property name. set: write property name = value. call: run method name with args. list: the items of a list property (or of the path itself).

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.6.1

TDQS

A4.9/5.0
Behavior5/5

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds substantial context beyond them: set/call require write=true, each change consumes exactly one undo step, invalid writes silently retain the old value, and underscore-prefixed names/modules/files are unreachable. It also discloses the return shape ({object, name, address}) and that results are plain JSON, which no annotation covers.

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

Conciseness5/5

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

Front-loaded with the purpose in the first clause, then workflow, then mutation caveats, then the sibling-preference rule, then output format, then access restrictions. Every sentence carries distinct information; there is no filler or repetition of the name/title.

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

Completeness5/5

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

For a 9-parameter, destructive, schema-only tool with no output schema, the description supplies the missing pieces: mutation gating, undo semantics, silent-failure behavior, result shape, and reachability limits. The confirm requirement for delete/remove/clear/stop_all is handled in the schema, so the definition as a whole leaves no material gap for correct invocation.

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% and the schema already documents path syntax, ref:t0/d1 passing, limit/offset, and the write flag. The description reinforces the operational semantics that matter most (write=true gating for set/call, member discovery via info before mutation) rather than restating parameter formats. It adds meaning beyond the schema but does not extend into areas the schema leaves thin, since none are thin.

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 names a specific verb-resource pairing ('Escape hatch to Live's object model') and enumerates the covered domains (Song, view, device, clip, mixer properties and methods). It immediately differentiates itself from siblings by scoping itself to 'anything the other tools do not cover.' An agent can tell this is the generic reflection layer, not a domain tool.

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?

Explicit when-not guidance: 'Prefer the dedicated tools when one exists; they check more,' which routes the agent away from this tool when a specialized sibling applies. It also gives an ordered workflow: start with info to discover members, then get, set or call. Both the selection rule and the invocation sequence are stated, not implied.

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