Skip to main content
Glama

Item (write)

item_write
Destructive

Change DaVinci Resolve timeline item state: flags, markers, takes, names, speed, fades, and properties. Every write is read back to verify it took.

Instructions

Change item state; may overwrite current values. Every change is read back from Resolve (receipt.verified=false means it did not take). op.action (params; * = required):

  • add_flag(items*, color*): Add a colored flag to items.

  • add_item_marker(item*, frame*, color, name, note, duration, custom_data): Add a marker on a timeline item.

  • add_take(item*, clip*, start_frame, end_frame): Add a Media Pool clip as a new take (creates the take selector if needed).

  • add_transition(item*, options*): Add a transition at the start or end of an item (needs source handles).

  • clear_flags(items*, color): Clear flags of one color, or all flags, on items.

  • copy_properties(source*, targets*, keys): Copy properties from one item to many (timeline snapshot taken first).

  • finalize_takes(item*): Finalize the take selection (the selected take replaces the selector).

  • flatten_multicam(item*, grade): Flatten a multicam item into its active angle (timeline snapshot taken first).

  • select_take(item*, index*): Select a take by 1-based index.

  • set_clip_color(items*, color): Set the clip color on items, or clear it when no color is given.

  • set_enabled(items*, enabled*): Enable or disable clips.

  • set_fades(items*, fades*): Set fade-in / fade-out durations (frames) on one or many items.

  • set_name(item*, name*): Rename a timeline item.

  • set_output_blanking(item*, blanking*): Set per-item output blanking in pixels (Top/Bottom/Left/Right).

  • set_properties(items*, properties*): Set properties on one or many items; each key is read back per item.

  • set_speed(items*, speed*): Set clip speed (Percentage, PitchCorrection...) on one or many items.

  • set_use_timeline_blanking(item*, use_timeline*): Choose between the timeline output blanking and the item's own.

  • smart_switch(item*, settings): Run Multicam Smart Switch on a multicam item (synchronous, may take minutes).

  • stabilize(items*): Run the stabilizer on items (can be slow; no read-back exists).

  • update_marker_custom_data(item*, frame*, custom_data*): Update the custom data string of an item marker. Calls known in advance (a sequence, the same change on several items): ONE batch_run.

Input Schema

NameRequiredDescriptionDefault
opYes{action, ...params}. Parameters per action: see the description or this server's describe_action tool.
dry_runNotrue: return the planned effect, change nothing.
snapshotNotrue: back up the timeline/project first; omitted: server policy.

Output Schema

NameRequiredDescriptionDefault
jobNo
planNo
statusYes
receiptNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed2 schema fields changedv1.0.4
    • addedInput schema / properties / dry_run / description
      Added value: +"true: return the planned effect, change nothing."
    • addedInput schema / properties / snapshot / description
      Added value: +"true: back up the timeline/project first; omitted: server policy."
  2. First observedv0.1.0

TDQS

A4.8/5.0
Behavior5/5

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

Goes well beyond the annotations: it discloses the read-back/verification contract ("receipt.verified=false means it did not take"), which actions take a timeline snapshot first, that stabilize has no read-back and can be slow, and that smart_switch is synchronous and may take minutes. These are exactly the operational traits an agent needs before committing a destructive write.

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-loads the risk statement, then a scannable one-line-per-action list, then the batching rule. Given 20 actions encoded in a single free-form object, the length is earned rather than padded.

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?

An output schema exists, and the description still adds the one return-value fact that matters (receipt.verified). Combined with dry_run/snapshot semantics implied by the per-action notes, an agent has everything needed to call any of the 20 actions correctly.

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

Parameters5/5

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

Schema coverage is technically 100%, but the nested op object is additionalProperties:true and explicitly defers to the description for per-action params. The description supplies that: every action's required (starred) and optional parameters, plus semantics like 1-based take index and frames units for fades.

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?

Opens with a specific verb+resource ("Change item state") and immediately qualifies it with the risk ("may overwrite current values"). The enumerated op.action list makes it unambiguous that this is the mutation counterpart to item_read/item_delete, and an agent can pick the right action 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 Guidelines4/5

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

Gives explicit routing for the multi-change case ("Calls known in advance ... ONE batch_run") and per-action prerequisites such as add_transition needing source handles and add_take creating the take selector if needed. It does not explicitly contrast itself with item_read or timeline_write, so it stops short of full when/when-not coverage.

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