Find the tool for your Premiere workflow.

Acknowledge user-reviewed reconciliation of uncertain execution after current-state inspection. Requires the exact latest recovery and host-state revisions. Consumed operation IDs remain unavailable for replay; acknowledgement does not undo or retry a host edit.

Actions or modes: backend: cep, uxp

EXPERIMENTAL (QE DOM): add an adjustment layer at the playhead on the specified track. Refuses when the host lacks the QE APIs; verifies a new public TrackItem using isAdjustmentLayer and placement readback.

Add audio level keyframes to create fades or level changes

Add a custom metadata field to the project's metadata schema. This creates a schema/column definition only; it does not set a per-item value. Use set_metadata field_name/value or complete Project Metadata XML with readback to update a value.

Add and read back a keyframe on an effect property. The receipt warns when its time is outside the clip's visible range. This verifies stored parameter data only; render/playback verification remains host-dependent.

Add a marker to the active sequence or a clip and read its name, comments, color and duration back. EXPERIMENTAL (QE DOM): the receipt reports undoStackIndex movement, which does not prove QE can reverse the marker. Every marker attempt protects an engine undo boundary; undoTracked:false means the marker did not observably advance the QE index.

Add a marker to a project item (source clip marker). EXPERIMENTAL QE: records an observed marker boundary for guarded Undo/Redo; crossing it is refused by default, and unreadable history records unknown protection. This boundary does not verify native marker reversal.

Actions or modes: type: Comment, Chapter, Segmentation, WebLink

Add up to 200 sequence or clip markers in one verified CEP request (beat grids, chapters, silence reviews, client notes). Every marker is validated and range-checked before the first write; the tool reads back the marker count and each created marker's time and fails closed on any mismatch. EXPERIMENTAL QE: records an observed marker boundary for guarded Undo/Redo; crossing it is refused by default, and unreadable history records unknown protection. This boundary does not verify native marker reversal.

Unavailable: Premiere does not expose a supported scripting API to create caption clips directly from raw text. For on-screen titles from plain text use add_title; for captions import an .srt/.vtt and use create_caption_track.

Actions or modes: caption_format: subtitle, 608, 708, teletext

Add an on-screen title from plain text using a stock Essential Graphics template that ships with Premiere (default: Basic Title). Pass text for one line, or lines to fill the template's text fields in order (for example a lower third's name and role). Premiere-built templates (kind 'premiere') get the text baked into a verified copy before import, because Premiere exposes no writable text for them (textVerification 'template_verified'; confirm the render with export_frame). The baked copy path is returned as templateFile and saved under the application support premiere-pro-mcp/titles folder (macOS: ~/Library/Application Support/premiere-pro-mcp/titles). The cache keeps the newest 50 baked copies by modification time; export or copy templates elsewhere if a project needs older copies retained. After Effects-built templates (kind 'after_effects') are imported and their text fields written by position and read back from Premiere (textVerification 'verified', 'mismatch', 'missing_property', or 'committed_unverified'). The graphic is trimmed to duration_seconds and its length read back. Use list_stock_titles to see templates, their kind, and how many lines each takes.

Request an Adobe Media Encoder render-queue handoff for the active sequence. Requires a saved project and an .epr preset_path. Same as Project presets are refused before Premiere is contacted because AME encodes from a scratch project copy. Optional start_batch requests processing of every ready AME queue job, including unrelated jobs.

Insert a project item at a timeline position. Experimental: if a target clip spans that point, QE razors it before insertion to attempt to preserve its tail; both target and sync-locked track changes are read back. A host may still displace a tail, in which case the edit is reported as committed_unverified. Pass scope 'target_tracks' to ripple only the named pair (this will desync other tracks).

Actions or modes: scope: sync_locked, target_tracks

Insert up to 32 project items with insert-edit semantics in one validated CEP request. Experimental QE sync-lock handling may ripple or split earlier placements. The tool preflights items and tracks, then verifies every placement again in the final sequence; changed placements return committed_unverified with their observed final positions.

Add verified video or audio tracks to the active sequence. Returns an error if Premiere cannot add the exact requested count.

Actions or modes: track_type: video, audio

Add video and/or audio tracks through QE, verify the active sequence gained the exact requested counts, and report explicitly when QE inserted the new tracks at index 0 and shifted every existing track up.

EXPERIMENTAL (undocumented QE DOM): Add a video transition between two clips at a cut point. Reads the transition back from the sequence track.

EXPERIMENTAL (undocumented QE DOM): Add a transition to a specific video clip's start, end, or both edges, then read back the requested placement.

Actions or modes: position: start, end, both

Add an installed native video transition to one unchanged video-clip edge through one undoable UXP transaction. Requires an exact inspect snapshot, serializes transition updates per sequence, and reads edge presence back; it does not prove handles, rendered appearance, or playback.

Actions or modes: position: start, end

Adjust a clip's Volume > Level in dB. Does not read or change Essential Sound Amplify automation.

Analyze caller-supplied, revision-bound transcript segments and optional local silence ranges for deterministic dialogue-edit candidates. It never calls a model, persists transcript text, or changes Premiere.

Measure integrated loudness (LUFS), loudness range (LU), and true peak (dBFS) from a local media file using FFmpeg's EBU R128 filter. Analysis only: it does not normalize audio or change Premiere.

Classify decoded video frames as progressive, top-field-first, bottom-field-first, mixed, or undetermined using FFmpeg idet. Read-only delivery preflight.

Analyze a local video delivery for sustained black and frozen sections with FFmpeg. Read-only: it does not contact Premiere or modify the file.

Import exactly one previewed completed AE render into its approved Premiere bin after rechecking both hosts and file metadata. Requires confirmation and consumes the token before dispatch. Does not save, render, or change a timeline.

Apply an audio effect to a clip. Experimental QE catalog lookup includes an exact-name probe when enumeration is empty. A component-list readback does not verify rendered audio.

Apply a reviewed beat grid as native sequence markers in one undoable Premiere 26.3+ UXP transaction, with bounded inputs and GUID/time readback for every marker.

Create a new ordinary dialogue derivative from an exact reviewed plan. It revalidates every transcript and never edits or deletes an original source or sequence.

Apply a previously previewed compound edit after revalidating stable project, sequence and target identities before activation or mutation. Requires the edit capability and exact preview confirmation token; changed targets require a fresh preview. Ripple plans require the reviewed sequence to be active for the read-only QE sync-lock preflight.

Apply selected organization recommendations through documented UXP bin transactions only. Requires the unchanged server-issued plan, its opaque preview confirmation token, and stable source/parent guards; individual host transactions may be partially committed and are never silently retried or rolled back.

Apply a video effect to a clip. Experimental QE DOM catalog lookup includes an exact-name probe when enumeration is empty. A component-list readback does not verify rendered pixels.

Consume a reviewed compound CEP token once and invoke only its existing typed tools with same-command project/sequence/clip/effect guards. Stops at first failed or unverified receipt, reports completed and unknown steps, and never retries or rolls back partial work. Rendering and audible synchronization remain separate evidence.

Unavailable on the CEP backend: Premiere's scripting API cannot load a LUT file into Lumetri Color. Its Input LUT and Look parameters are menu indexes over a curated set of bundled looks, and writing a file path to the LUT asset parameters is accepted but not rendered (seen on Premiere Pro 25.2.3, macOS, by comparing exported frames with the same LUT applied by ffmpeg; other builds were not tested). Fails before changing the clip. Apply the LUT in Lumetri Color > Creative > Look (Browse...) instead.

Import exactly one previewed MOGRT into the empty track of the explicit disposable Premiere verification sequence, then read back insertion and control descriptors. Requires explicit confirmation; no rendered-frame claim is made.

Consume approved source-scene preview once, create reviewed source markers and/or subclips requesting audio in a new verified bin using existing typed CEP tools. Same-command source/project guards refuse relinks or project changes. Stops on failed/unverified receipt and retains bounded partial results; no rollback or false-positive correctness claim.

Apply one exact previewed motion-demo, product-spot, or brand-spot plan. Requires edit authority, requires filesystem authority for a MOGRT, and only targets empty explicitly named tracks. Host readback is not playback or render verification.

Apply one single-use reviewed ordinary stacked-camera plan to a newly cloned sequence. Reads actual track locks, linked partners, source identity, forward1x speed and nest/reverse state before clone and before writes; unavailable getters refuse. Verifies exact enabled states and master-audio ranges. Sequential partial completion is reported; no rollback or audible sync claim.

Attach a custom property (key/value pair) to the active sequence and confirm it against the sequence project item's XMP packet. Reports failure when the property never lands in XMP.

Audit documented Object Mask presence across up to 64 Premiere sequences without changing the project. Omit sequence_ids only when the entire active project has at most 64 sequences; otherwise pass explicit exact GUIDs. The bridge double-reads the active-project identity, aggregate result, and every selected sequence result, rejecting drift instead of returning a mixed audit. It reports only yes/no presence—not mask count, location, tracking, editability, rendered pixels, or playback correctness.

Audit one sequence snapshot for flash frames, gaps, overlaps, disabled clips, repeated shots, video without audio, extreme speed, invalid times, empty tracks, leading black, and trailing gaps; returns a 0..100 score, findings with timecodes, and fix routes. Local-only; never changes Premiere.

Open a selected project item or approved file, inspect/set position, play at bounded speed, or close Source Monitor media through documented UXP APIs.

Actions or modes: state, open_project_item, open_file, set_position, play, close, close_all

Auto-reframe a sequence into a new sequence of target_width x target_height. Premiere derives the new sequence from the source height (a 1080p source at 9:16 comes out 607x1080), so the tool then sets the requested frame size and verifies it; the Auto Reframe effect refits to the new size.

Actions or modes: motion_preset: slower, default, faster

Inspect or transactionally set scalar effect parameters; inspect or guardedly set static PointF x/y and Color RGBA parameters; locate individual keyframes including a bounded native nearest-range lookup; adjust keyframes/interpolation; and control explicit time-varying animation mode through documented UXP actions. Interpolation verification covers the stored mode only, not rendering; Premiere 26.5.2 Windows has a reported temporal-curve render gap. Inspect playback or exported pixels. Disabling animation requires a complete inspected keyframe-time snapshot and confirmation.

Actions or modes: inspect, inspect_point_value, inspect_point_displacement, set_point_value, inspect_color_value, set_color_value, inspect_keyframe, set_value, add_keyframe, remove_keyframe, remove_keyframe_range, set_interpolation, inspect_time_varying, set_time_varying

EXPERIMENTAL (undocumented QE DOM): Add the same video transition at each eligible cut point on a track and report per-cut readback.

Apply one audio or video effect to compatible selected clips, a compatible track, or all compatible clips. Every target is preflighted and then checked by component-count readback.

Actions or modes: target: selected, track, all; track_type: video, audio

Enable or disable multiple clips at once (selected, track, or all).

Actions or modes: target: selected, track, all; track_type: video, audio

Rename multiple clips on the timeline using a pattern. Supports sequential numbering.

Actions or modes: track_type: video, audio

Inspect the current timeline selection or apply one native effect add/remove across up to 64 same-type selected clips as a single compound transaction. Effect readback verifies component-chain changes only, not rendered output.

Actions or modes: inspect, add_effect, remove_effect

Bind approved source/proxy content hashes and original availability to an analysis provider and timeline revision. Proxy flags do not prove delivery provider; caller-evidenced full-resolution export remains distinct from artifact validation.

Build a CapCut/Submagic-style SRT or VTT caption artifact from a caller-supplied word timeline: balanced word groups, sentence-aware breaks, min/max cue durations, optional karaoke word timestamps (VTT), emphasis and speaker markup. Local-only; returns the artifact inline or writes it inside an approved workspace and never changes Premiere.

Actions or modes: format: srt, vtt; style_preset: clean, bold_pop, karaoke, podcast, lecture

Create new before/after contact sheets, optional bounded MP4 excerpts, and checksum receipts from two reviewed rendered videos. Supports visual review of cuts, transitions, titles and masks; still grids do not verify temporal behavior or authenticate host lineage.

Inspect explicitly listed dependencies inside an approved consolidated workspace. Reports observed bytes, missing files, expected source identity and unresolved nests/image sequences/AE/template dependencies. A copied project alone cannot pass completeness.

Calculate one bounded add, subtract, multiply, or divide operation using Premiere's documented native TickTime arithmetic over canonical tick integers. It returns native ticks and seconds readback only. It deliberately does not accept seconds or frame rates, align to frames, infer timecode, inspect any Premiere project object, mutate Premiere, or prove a licensed host.

Actions or modes: operation: add, subtract, multiply, divide

Validate an exact tool invocation, authority, live backend and bounded CEP targets without applying it. Returns named refusal/unknown reasons and evidence age; preflight is advisory and must be revalidated at dispatch.

Request cancellation of an owned local process or undispatched local job. Native Premiere/AME cancellation is unsupported; no queue is cleared and no output file is deleted.

Capture the current frame and return it as inline image data for the LLM to see. This supports still-image review only. The PNG keeps the sequence's transparency (hasAlpha); transparent areas may display as white or a checkerboard rather than the black a video render shows.

Check caption, title, logo, and graphic rectangles against approximate platform UI overlay zones (TikTok, Reels, Shorts, feed, YouTube, LinkedIn, X) and suggest the nearest clear position. Local-only geometry on caller-supplied normalized rects; it never reads or changes Premiere.

Actions or modes: platform: tiktok, instagram_reels, youtube_shorts, instagram_feed, youtube, linkedin, x

Check for offline (missing) media in the project

Clear in and/or out points on a project item (reset to full duration). Still-image Out is independently verified only when its own duration is readable; otherwise the result explains that limit.

Clear the in and/or out points on the active sequence so they read back as unset, and leave the other point unchanged.

Close all clips in the Source Monitor.

Close an open Premiere Pro project: the active one, or the open project at project_path. Verifies it is no longer open and reports which project is active afterwards.

Request closing a sequence timeline tab. Premiere exposes no open-tab enumeration, so dispatch is requested_unverified; the sequence stays in the project.

Close the clip currently showing in the Source Monitor. Premiere then shows the previously opened clip, if any; the result names it.

Apply basic color correction through experimental QE Lumetri insertion. Requires Lumetri component and requested property readback; rendered output is not verified.

Compare two local CMX 3600 EDLs by event number and report bounded added, removed, and changed editorial events. Read-only; it does not alter either interchange file or Premiere.

Inspect only. Compute the Motion Scale (%) and Position that place a still image's subject inside an existing Rounded Crop, Crop, or similar mask effect. Reads the sequence frame size, the source frame size, current Motion values, and the mask effect's parameters, then solves the geometry deterministically from a caller-supplied subject box (fractions of the source image, for example head-top to chin). No image analysis and no changes to Premiere. Apply the result with set_clip_scale and set_clip_position (or set_effect_property), then verify with capture_frame. Assumes Rotation 0 and uniform scale; mask geometry is treated as fixed in the sequence frame (mask_space 'sequence').

Actions or modes: mask_space: sequence, clip; fit_axis: height, width

Launch or configure Adobe Media Encoder and optionally start its queued batch using Premiere 26.3+.

Collect (copy) or transcode project media into a new project with Premiere's Project Manager. Premiere writes a Copied_<project> folder inside destination_path (created if missing); success is reported only after that folder holds the copied .prproj, with the copied files listed.

Consolidate duplicate project items and report success only when duplicate media groups decrease.

Convert exact Premiere tick strings, rational frames, samples, decimal seconds and signed/drop-frame timecode locally. Nearest ties round away from zero; intervals use inclusive start and exclusive end. No floating-point tick parsing or host dispatch.

Actions or modes: from: ticks, frames, samples, seconds, timecode; to: ticks, frames, timecode; rounding: floor, ceil, nearest

Copy verified scalar and colour effect-property values from one effect to the matching effect on another clip. Both clips must already have the same effect applied. Properties are matched by position, then by unique display name, because effects such as Lumetri Color repeat names across sections. Legacy CEP deliberately refuses Blend Mode because Premiere can corrupt its enum value on cross-clip writes.

Copy all effects (or a specific effect) from one clip to another, including parameter values and keyframes, and read every written value back. A missing effect is added through the experimental legacy QE DOM; when the target already has that effect, its values are updated instead of stacking a second default-valued instance. Intrinsic components such as Motion and Opacity are skipped unless named. Uses the same component matching and per-property receipts as paste_clip_attributes.

Create a Bars and Tone synthetic media item in the project (useful for leader/calibration). Returns the created item's name, nodeId, and treePath, found by reading the project back.

Create a new bin (folder) in the project panel, optionally nested inside an existing bin. Reads the project back: verified is true only when the new bin is a direct child of the requested parent; otherwise the result reports outcome committed_unverified.

Import an already reviewed caption artifact into the active sequence, or create a local lecture-caption timing and review workflow plan. Import rejects unsupported formats before host dispatch and reports structural success only when valid count readback shows exactly one new caption track. Unreadable or unexpected results preserve committed_unverified diagnostics; inspect before retrying. The planning action never contacts Premiere or changes an artifact.

Actions or modes: import, plan_lecture_workflow

Create a non-mutating, evidence-backed edit-plan scaffold from indexed Premiere context. It returns ranked source/time candidates and stale-state guards; the model must review them and use preview_edit_plan before any mutation.

Actions or modes: strategy: rough_cut, select_ranges, review

Create a compact Markdown reading view from already captured local transcript, shot, audio, note, source, or timeline context. It returns stable evidence IDs and context revisions for review, never calls an AI/provider or Premiere, and cannot change the project.

Create a local, evidence-backed editorial workflow plan from captured project context. It never calls an LLM, uploads media, or changes Premiere.

Actions or modes: workflow: organize, stringout, rough_cut, caption_review, platform_cutdown

Create one empty/default sequence through the documented Premiere 26.3+ UXP API. This direct, non-undoable host call requires explicit confirmation and an operation_id; the host serializes capacity preflight through identity readback and replays the receipt safely.

Create the exact MOGRT recipes from a one-time batch preview. Requires explicit export confirmation and stops on the first After Effects failure without claiming rollback.

Create exactly one previewed MOGRT recipe in a saved After Effects project inside the approved workspace. Requires explicit export confirmation; it never creates projects or output folders.

Create a new Premiere Pro project at the specified path

Create a collision-safe, byte-verified backup beside an existing .prproj file without opening or modifying the source project.

Inspect a bounded native Project-panel schema or request one typed Project metadata field through Adobe's documented direct UXP API. Creation requires the exact inspected project GUID/XML, explicit confirmation, and a replay key; it is non-undoable and reports host acceptance plus schema-change readback without claiming field-level verification or atomic compare-and-set semantics.

Actions or modes: inspect, create

Create a new sequence in the project

Clone a sequence into a named '[checkpoint]' copy before a risky edit and return a diff_sequence_snapshots-compatible snapshot of the original. Verifies the clone exists with matching track and clip counts, re-activates the original, and never deletes or overwrites anything.

Create a new sequence from project items, then verify its registered identity, name and source-item placements. clipCount reports observed track items; requestedClipCount reports requested source items.

EXPERIMENTAL (undocumented QE DOM): create a new sequence from a specific preset file (.sqpreset) using qe.project.newSequence. Reports success only after a new sequence ID appears in the project collection; a same-name sequence that was already active is not treated as created.

Create one sequence from a workspace-gated .sqpreset path through the documented Premiere 26.3+ UXP API. This direct, non-undoable host call requires explicit confirmation and an operation_id; the host verifies the created sequence identity and replays the receipt safely.

Create a new single-source rough-cut stringout from reviewed silence ranges using documented Premiere 26.3+ hard-bounded linked A/V subclips. It does not preserve or modify an existing edited timeline.

Create a smart bin (search bin) and inspect its new identity and name. The stored search query has no getter, so creation reports committed_unverified with identity verification separately.

Create a subclip from a project item with in/out points. Returns the new item's nodeId and reads its stored range back from Premiere project metadata: outcome verified when the observed in/out seconds are within one media frame of the request, otherwise committed_unverified.

Create and verify a Premiere 26.3+ subclip in an undoable transaction. Prefer project_item_id; a name must resolve to exactly one media clip.

Create a separate subsequence from selected clips or a time range. This Premiere API does not replace the original timeline clips with a nested-sequence reference.

Apply or update Premiere's Crop effect on one video clip and read back every requested value. Adding Crop uses the legacy QE catalog only when the clip does not already contain it.

Delete a bin (folder) from the project panel

Delete a marker at a specific time position. EXPERIMENTAL (QE DOM): the receipt reports undoStackIndex movement, which does not prove QE can reverse the marker. Every marker attempt protects an engine undo boundary; undoTracked:false means the marker did not observably advance the QE index.

Delete several project items (bins, sequences, clips or files) and read back that each is gone. Every item is checked before any is deleted. organize_project_items_uxp with action 'remove' (authenticated UXP bridge) is the preferred, documented route; this CEP fallback deletes clips and files through a temporary bin, which cannot be undone here. Items (or bins whose contents are) used on a timeline are refused unless confirm_remove_from_sequences is true.

Delete all preview/render cache files for the project. Uses QE DOM.

Delete a project item (bin, sequence, clip or file) from the project panel and read back that it is gone. organize_project_items_uxp with action 'remove' (authenticated UXP bridge) is the preferred, documented route. This CEP fallback deletes a clip or file by moving it into a temporary bin and deleting that bin, which cannot be undone here. Deleting media also removes its clips from every sequence, so an item (or a bin whose contents are) used on a timeline is refused unless confirm_remove_from_sequences is true.

Delete a sequence from the project

EXPERIMENTAL (undocumented QE DOM: removeVideoTrack/removeAudioTrack). Delete a video or audio track from the active sequence through QE and verify that exactly that track was removed (the remaining tracks keep their clips, custom names and lock/mute state in order). Refuses a track that still holds clips unless force is true.

Actions or modes: track_type: video, audio

Deselect all clips in the active sequence.

Detach/remove the proxy from a project item and read hasProxy back; unavailable readback reports committed_unverified.

Detect the most frequent active-picture crop rectangle in decoded video, exposing probable letterbox or pillarbox bars without modifying the source.

Find probable beat or edit-point transients from decoded audio peaks. Returns candidates for editorial review; it does not claim musical beat-grid accuracy or change a timeline.

Estimate a steady beat grid from a local audio or video file without changing Premiere. FFmpeg decodes at most 30 minutes to a bounded mono analysis stream; local onset autocorrelation returns BPM, phase-aligned beat times, confidence, and half/double-time alternatives.

Find probable high-motion moments in a bounded local video sample from decoded frame differences. Read-only editorial candidates; camera movement, flashes, cuts, and subject motion are not semantically distinguished.

Detect whether the active project or sequence contains an Object Mask using Premiere 26.3+.

Actions or modes: scope: sequence, project

Detect repeated sentence takes (retakes) in a word timeline using token similarity within a time window, and plan removal of all but the kept take. Returns take groups, removal and keep ranges, and apply routes. Local-only; never changes Premiere.

Actions or modes: keep: last, first

Safe scene-edit facade. It uses the authenticated Premiere UXP bridge when connected and explicitly confirmed; CEP fallback is intentionally withheld because synchronous scene detection can block the panel.

Actions or modes: mode: apply_cuts, create_markers, create_subclips

Run Premiere's documented scene-edit detection on the current timeline selection using cuts, markers, or subclips. create_markers still runs when a selected item has no marker collection and reports committed_unverified if no markers can be read back. This direct host mutation is not claimed undoable.

Actions or modes: mode: apply_cuts, create_markers, create_subclips

Find silent ranges in a media file and return both the silences and the complementary segments worth keeping. Analysis only — nothing in the project or on the timeline is modified. Requires ffmpeg on PATH: Premiere's scripting API exposes no audio-level or waveform data, so silence cannot be measured through the bridge.

Detect probable visual cuts in a local source file using FFmpeg scene scores. Read-only and source-relative; it does not cut a Premiere timeline.

Diff two sequence snapshots (from get_sequence_structure or inspect_sequence_structure_uxp) into added, removed, moved, trimmed, retimed, enabled, and renamed clip changes with frame deltas, per-track counts, and EDL-like timecode lines. Local-only; never reads or changes Premiere.

EXPERIMENTAL: Duplicate a timeline clip, with its linked audio/video partner, onto the first tracks above it that are empty for the clip's time range. The copy keeps the clip's source in point and visible duration, is placed with an overwrite edit (nothing ripples), and is read back. A post-write mismatch is committed_unverified; inspect the timeline or use Undo. Fails without changes when no free track is available; add one with add_tracks.

Duplicate an existing sequence

Inspect or append one guarded duplicate of the final audio or video clip on a track using documented UXP SequenceEditor actions. Apply requires the complete source snapshot, explicit confirmation, and an operation ID; it serializes with guarded slips and slides on that track, commits one transaction, and reads back only the original and appended item. It intentionally cannot duplicate into an occupied range, another track, or a linked A/V pair. It does not prove media handles, linked A/V synchronization, rendered frames, playback, persistence, or Undo behavior.

Actions or modes: inspect, apply

Use the documented SequenceEditor to insert, overwrite, clone, remove, or insert MOGRT content without undocumented QE calls. MOGRT inserts act on the active sequence and read the placement back: verified when a returned item starts at time_seconds (within one frame) on the requested video track, failed when nothing is there.

Actions or modes: insert, overwrite, clone_selection, remove_selection, insert_mogrt_path, insert_mogrt_library

Enable or disable a clip on the timeline

Request an Adobe Media Encoder encode for an external file. Requires a saved project. The returned job ID is an unverified handoff; verify queue presence or the output file independently. Optional start_batch requests processing of every ready AME queue job, including unrelated jobs.

Preflight, queue, or inspect and wait for conservatively correlated AME receipts inside the approved workspace. A terminal event is not output-file verification.

Actions or modes: preflight, jobs, wait, sequence, project_item, file

Request an Adobe Media Encoder encode for a project item. Requires a saved project. The returned job ID is an unverified handoff; verify queue presence or the output file independently. Optional start_batch requests processing of every ready AME queue job, including unrelated jobs.

Queue exactly one previewed After Effects render with named host templates. Requires explicit confirmation; it saves the open project but never starts rendering or overwrites output.

Evaluate a simple ExtendScript expression and return its value. Use for quick queries like checking a property, getting a count, or reading state. The expression should be a single value/call — NOT a full script. Examples: - "app.project.name" → project name - "app.project.activeSequence.name" → active sequence name - "app.project.rootItem.children.numItems" → number of root items - "app.project.activeSequence.videoTracks.numTracks" → number of video tracks - "app.version" → Premiere Pro version

Execute custom ExtendScript code in Premiere Pro. The code runs inside an IIFE with helper functions available. IMPORTANT: You MUST write ES3 syntax (var instead of let/const, no arrow functions, no template literals, no destructuring). Available helpers (auto-prepended): - __ticksToSeconds(ticks) / __secondsToTicks(seconds) — time conversion - __ticksToTimecode(ticks, fps) — timecode string - __findSequence(idOrName) — find sequence by name or ID - __findProjectItem(nodeIdOrName) — find project item recursively - __findClip(nodeId) — find clip in active sequence, returns {clip, trackIndex, clipIndex, trackType} - __getAllClips(seq) — get all clips in a sequence - __result(data) — return success with data (MUST call this or __error) - __error(msg) — return error message - TICKS_PER_SECOND — constant 254016000000 - app.enableQE() — enable QE DOM access Your code MUST end with: return __result({...}) or return __error("message") Example: Set opacity to 50% on all video clips var seq = app.project.activeSequence; if (!seq) return __error("No active sequence"); var count = 0; for (var t = 0; t < seq.videoTracks.numTracks; t++) { var track = seq.videoTracks[t]; for (var c = 0; c < track.clips.numItems; c++) { var clip = track.clips[c]; for (var i = 0; i < clip.components.numItems; i++) { var comp = clip.components[i]; if (comp.displayName === "Opacity") { for (var p = 0; p < comp.properties.numItems; p++) { if (comp.properties[p].displayName === "Opacity") { comp.properties[p].setValue(50, true); count++; } } } } } } return __result({updated: count});

Unavailable on the CEP backend. Use export_aaf_uxp with an authenticated Premiere 26.3+ UXP bridge.

Export the active sequence as AAF through Premiere 26.3+ UXP with bounded, typed AAF options. Premiere confirms the request, but arbitrary native output paths cannot be statted by the panel.

Preflight and directly render a guarded CEP sequence, then independently hash and probe the exact output against a delivery contract and optional decoded QC. Refuses existing destinations; never treats queue acceptance as completion.

Actions or modes: range: entire, in_to_out, work_area

Export the active sequence as a Final Cut Pro XML file. Sequences with effects FCP XML cannot represent can make Premiere show a Translation Report modal after writing the XML; dismiss it in Premiere before any queued command can run. Detects the written XML and fresh report if the modal blocks the host. Default wait is 60 minutes for long sequences.

Export a sequence as a standalone Premiere Pro project file. Fails when Premiere writes no file or leaves a pre-existing output unchanged.

Create a new bounded ALE facility metadata table from reviewed named field rows. Rejects duplicate columns, unknown row fields and tabs/newlines that ALE cannot safely represent. No project metadata is read or changed; verify downstream facility import separately.

Export a file-verified still image. PNG stills keep the sequence's transparency (straight alpha, reported as hasAlpha); composite them over black before measuring brightness or comparing with a video render. A single still does not verify motion over time, playback or audio.

Export a sequence frame through Premiere's supported UXP Exporter, then check in the host panel that the PNG exists. Returns outcome verified when a new file is found, committed_unverified when UXP storage cannot check or the file already existed, and fails when no file was written.

Export the active sequence through its documented format-specific OpenTimelineIO or Final Cut Pro XML UXP method. Host acceptance is committed_unverified. Opt-in local artifact inspection requires filesystem authority and distinguishes fresh parsed bytes from host/destination/round-trip proof.

Actions or modes: format: otio, fcpxml

Export the active sequence as an OMF file (Open Media Framework, for audio post-production). Long sequences can use a longer wait (default 60 minutes); if Premiere writes the file but times out, the receipt includes its size as committed_unverified.

Create a new bounded review-marker CSV or JSON from caller-reviewed marker readback. Includes exact ticks, rational rate, source/sequence identity and display timecodes with explicit start offset/drop-frame policy. CSV text escapes spreadsheet formula prefixes, quotes and newlines. Existing files are never overwritten.

Actions or modes: format: csv, json

Export the active sequence directly (Premiere renders it; blocks until done) with an Adobe Media Encoder preset. The output extension must match what the preset writes (an H.264 preset in AME's QuickTime folder writes .mov); a missing extension is added. Refuses an output_path that already exists unless overwrite is true. Fails if Premiere rejects the render, and verifies a non-empty file was written (for an overwrite, that the file changed). range 'work_area' fails closed unless the work area is enabled and covers only part of the sequence — otherwise Premiere would encode the entire timeline.

Actions or modes: range: entire, in_to_out, work_area

Export one file-verified still frame at the midpoint of each clip on a chosen video track in one bridge request. Read-only in Premiere; it does not mute tracks or claim visual quality.

Generate a CMX 3600 EDL for one video or audio track of a sequence from Premiere timeline readback (cuts, reels, source/record timecode, M2 lines for retimed clips), self-validate it, and return it inline or write it inside an approved workspace. Premiere is only read; this is not a Premiere-native export. Long sequences can use a longer timeout (default 30 minutes).

Actions or modes: track_type: video, audio; frame_rate: 24, 25, 29.97, 30, 50, 59.94, 60; reel_mode: clip_name, tape_name, numbered

Export up to 24 file-verified still frames at active-sequence marker positions in one bridge request for marker-driven review. It reads markers and writes image files only; it does not add, update, or remove Premiere markers.

Export 2-24 evenly spaced, file-verified frames from an active-sequence range in one bridge round trip for visual review. Still capture does not verify temporal animation, playback, audio, or editorial quality; PNG frames keep the sequence's transparency (straight alpha), so composite them over black before comparing with a video export.

EXPERIMENTAL (undocumented QE DOM: extract()). Extract (remove and close the gap) the content between the sequence in/out points on every targeted, unlocked track, then verify each targeted track lost exactly the range and its later clips moved up by the range. Marks that Premiere stored just off a frame are first re-written on that exact frame through QE (marksRewritten). Requires sequence in/out marks that do not span the whole sequence. Premiere can also change untargeted tracks (for example the linked audio of targeted video, or sync-locked tracks); those are not verified but are listed in otherTracksChanged.

Find project items whose media path contains the given search string

Find a project item by name (searches recursively through bins)

Create a freeze frame from a clip at a specific time. Exports the frame and imports it back as a still image.

Generate a new, disk-verified PNG contact sheet from evenly sampled source frames. Refuses to overwrite an existing output and does not modify Premiere or the source.

Get bounded, paged information about the currently active sequence (50 clips by default). Follow pagination.nextOffset for more

Actions or modes: track_type: video, audio, both

Report public-API support, prerequisites, entitlements, and user-assisted boundaries for Premiere collaboration and AI features

Actions or modes: backend: cep, uxp

Get all unique media file paths used in the project. Useful for asset management and archiving.

Report the documented automation boundary for advanced audio and modern color management, including actionable reasons for UI-only features.

Get detailed contents of a specific bin (folder) including all nested items, media paths, offline status, color labels, and metadata. Searches by bin name or node ID.

Inspect privacy-preserving aggregate bridge health: pending command/response counts, busy operations, queue age, and CEP heartbeat state without returning project or personal data.

Discover Premiere operations and report backend coverage, authority, and verification requirements. Use tool_query with task keywords (for example transcript, captions, or review frames) for ranked, bounded matches available in this session. Use tool_names for exact lookups or tool_offset/tool_limit for paging. Discovery never grants authority or proves a live host is ready.

Returns caption style presets (clean, bold_pop, karaoke, podcast, lecture) with font, position, and styling recommendations, plus Premiere UI steps for applying styles. Read-only guidance; NEVER modifies caption tracks. Use build_caption_artifact for SRT/VTT timing, then import via create_caption_track and apply styles manually in Premiere's UI.

Actions or modes: preset: clean, bold_pop, karaoke, podcast, lecture

Check if a clip is an adjustment layer

Get all clips at the current playhead position across all tracks.

Actions or modes: track_type: video, audio, both

Get the clip at a specific time position on a track

Actions or modes: track_type: video, audio

Get information about linked clips (audio/video linked together) for a given clip.

Get all markers on a specific project item (source clip markers, not sequence markers).

Get detailed properties of a specific clip by its node ID

Get the playback speed and reverse state of a clip

Export Premiere's native transcript JSON for one source media clip. Returns a revision hash that must be used when previewing transcript edits. This is read-only and does not run Speech-to-Text.

Read an audio clip's Volume > Level in dB. Use this to verify a level actually applied - setValue() clamps silently. Does not report Essential Sound Amplify automation.

Get the color label of a project item

Get the color space information for a project item

Find project items that reference the same source media file. Useful for consolidation. After Effects compositions imported from the same .aep/.aepx are only grouped when their comp names also match. Groups are paged (default 100) and can be filtered by a case-insensitive item-name substring; follow nextOffset while truncated is true.

List all properties of a specific effect on a clip, including current values

List available Adobe Media Encoder export presets, with the .epr path of each so it can be passed to export_sequence or encode_project_item. Presets are discovered by scanning the .epr files Adobe ships on disk (Premiere's ExtendScript API exposes no preset enumeration).

Get the export file extension from Premiere. If Premiere returns none, infer it only for an existing .epr in a recognized Adobe Media Encoder format folder; that fallback is marked unconfirmed and should be checked before delivery.

Get footage interpretation settings for a project item

Get exhaustive information about a specific clip: all effects with every property value, source media details, footage interpretation, metadata, markers, speed, enabled state, color label, linked clips, and proxy status.

Get a comprehensive overview of the project. Use include_bin_tree false or sequence_offset/sequence_limit for a bounded response on large projects.

Get bounded information about a sequence (50 clips by default; follow pagination.nextOffset; markers and transitions capped at 50 per collection): settings, all tracks with lock/mute/target state, paged clips with positions/effects/speed/enabled state, bounded markers, transitions, in/out points, and work area.

Actions or modes: track_type: video, audio, both

Get the graphics white luminance value (HDR setting) for the project

Get the current target bin for new imports (the bin that is currently focused in the Project panel)

Get detailed type info about a project item (is it a sequence, multicam, merged clip, etc.)

Get all keyframes for a specific effect property on a clip. Each key's time is in seconds from the clip's start; mediaSeconds is Premiere's stored media time.

Get all clips in the sequence that are linked to the same source as a given clip

Get metadata for a project item. Returns bounded parsed fields by default; GPS, serials, and personal contact/author fields are omitted. Raw packets require explicit include_project_metadata/include_xmp_metadata and include_sensitive true. Media paths require include_media_path true. Project metadata XML and file/clip XMP are separate packets; disable either when identity/path is enough. Prefer inspect_project_panel_metadata_uxp item_columns or manage_metadata_uxp inspect_fields for visible columns. This is not the premiere://project/metadata resource. GPS and serials are omitted from parse_fields unless include_sensitive is true.

Get MOGRT (Motion Graphics Template) component parameters from a clip. Each parameter includes textValue (visible text extracted from textEditValue when present). Pass expected_values to audit text controls such as Headline; the result flags verified, mismatch, or missing_property per field. Reads the stored property, not the Essential Graphics panel display, which Premiere can show stale (host UI behavior this tool cannot refresh).

Find the next or previous edit point (clip boundary) from the playhead position.

Actions or modes: direction: next, previous; track_type: video, audio, both

Find all offline/missing media in the project with their expected file paths. Essential for diagnosing broken links.

Read content-free local median/p95 stage timing, payload sizes, and bounded analysis cache occupancy. Missing measurements remain unknown.

Get the current playhead (CTI) position in the active sequence

Get a comprehensive snapshot of the current Premiere Pro state: project info, active sequence, playhead position, selected clips, and available sequences. The best first call to understand the current context.

Get information about the currently open Premiere Pro project

Get detailed information about a project item (media file in the project panel): media path, resolution, duration, frame rate, codec info, metadata, color label, offline status, in/out points, and proxy status.

Get the current Project-panel column layout as XML. This is schema/layout configuration, not per-item Scene/Shot/Take values; use inspect_project_panel_metadata_uxp item_columns or get_metadata for those. Output is capped by max_chars (default 20000); when truncated is true the XML is incomplete and must not be passed to set_project_panel_metadata.

Get the project's scratch disk locations (captured media, previews, auto-save, Motion Graphics template media, and more). Premiere's scripting API has no scratch-disk getter, so the settings are read from the saved .prproj file; unsaved changes are not reflected. 'SameAsProject' resolves to the project's folder.

Get QE DOM information about a clip, including properties not available through the standard API.

Actions or modes: track_type: video, audio

Report the Adobe Media Encoder queue running state, or fail closed with a named capability error when this Premiere build exposes no queue-status method on app.encoder.

Get the currently selected clips in the active sequence

Get the total number of sequences in the project.

Get the current sequence in and out points

Get all markers of a specific type (comment, chapter, web link, etc.) from a sequence.

Actions or modes: marker_type: Comment, Chapter, Segmentation, WebLink, FlashCuePoint

Get the settings (resolution, frame rate, etc.) of a sequence

Get a bounded structural page of the active sequence (50 clips by default; follow pagination.nextOffset): all track counts, paged clips with positions, gaps, and clip metadata. Essential for understanding timeline state before making edits.

Actions or modes: track_type: video, audio, both

Get information about the clip currently loaded in the Source Monitor.

Get the current time indicator position in the Source Monitor

Get which tracks are currently targeted for editing. Premiere allows several video or audio tracks to be targeted at the same time; every targeted track is listed. Tracks whose state cannot be read are listed under unreadable.

Find a bounded page of gaps (50 by default; follow pagination.nextOffset) on the timeline between clips. Useful for identifying where content is missing or where clips can be tightened.

Actions or modes: track_type: video, audio, both

Get a human-readable summary of the timeline: total duration, clip count per track, total gaps, coverage percentage, used media files, effect usage, and marker overview. Great for a quick understanding of sequence state.

Get the total number of clips across all tracks in the active sequence.

Get detailed information about a specific track: name, clip count, muted, locked, targeted, and list of all clips.

Actions or modes: track_type: video, audio

List transcription languages supported by the connected Premiere 26.3+ host.

Find project items that are NOT used in any sequence. Useful for cleaning up projects. Results are paged (default 100 items) and can be filtered by a case-insensitive name substring; follow nextOffset while truncated is true.

Get a report of all media files used in a sequence: which source files are used, how many times each appears, on which tracks, and whether any sources are offline.

Report the authenticated local UXP bridge connection and the capabilities advertised by the connected Premiere host.

Read the active project, sequence, and playhead state through the connected Premiere UXP bridge.

Report whether the Premiere panel has an operator-approved persistent workspace folder. The native path and persistent token are never returned.

Get the interpolated value of an effect property at a time, in seconds from the clip's start

Get Premiere Pro version and build information.

Get the current work area in and out points

List all available workspace layouts in Premiere Pro

Inspect bounded file/clip XMP fields with GPS, serials, author and contact data omitted by default. Raw XMP requires include_raw and include_sensitive true; it can disclose personal data to the connected client. Distinct from Premiere-private project metadata.

Check if a project item has a proxy attached

Check whether a source media clip has a transcript, preferring Premiere 26.3's documented native API when available.

Import After Effects compositions from an .aep file, failing closed when the file does not exist or when the target bin gains no items.

Unavailable by design: CMX 3600 EDL import opens Premiere UI that can block the CEP bridge. No import is attempted; convert the EDL to FCP7 XML and use import_fcp_xml for unattended interchange.

Import a Final Cut Pro XML file. Default mode new_project opens it as a new Premiere project: app.openFCPXML(path, projPath) requires a destination project path, and verified is true only when that destination exists as a file and Premiere has that exact path open. Mode into_open_project instead imports the XML into the currently open project with project.importFiles and succeeds only when the sequence count grew; the XML also brings its own clips, which can duplicate existing items.

Actions or modes: mode: new_project, into_open_project

Import the media files directly inside a folder and read the destination tree back. Refuses an unreadable baseline before importing. Reports observed new media items; unreadable or unmatched imports are committed_unverified. Host errors retain partial-change diagnostics; inspect the destination before retrying.

Import a numbered image sequence as a single video clip.

Import media files into the project and confirm a new project item for each file

Import a Motion Graphics Template (.mogrt) file and add it to the timeline. Pass text_values (for example { "Headline": "..." }) to write each text control explicitly after insertion and verify it by readback, so a template default or stale value is never left in place silently.

Request importing a MOGRT from a named Adobe Creative Cloud Library. Library contents cannot be enumerated through CEP; host acceptance is committed_unverified, and rendered appearance must be checked in Premiere.

Import workspace-contained media files, sequences, or After Effects compositions through documented Project APIs with post-state evidence.

Actions or modes: files, sequences, ae_comps, all_ae_comps

Import sequences from another Premiere Pro project file

Import native transcript JSON onto one untranscribed source media clip through documented Premiere 26.3+ UXP APIs. Check has_transcript_uxp first and omit expected_transcript_revision (or pass null). Importing over an existing transcript is refused (UXP_TRANSCRIPT_OVERWRITE_REFUSED): on Premiere 26.5.1 a failed import cleared an existing transcript that could not be restored. This destructive import requires explicit confirmation and an operation_id, serializes competing imports for the same project item, runs one undoable transaction, and reports bounded exact or canonical full-content export readback; JSON key order and numeric spelling may change while timings, speakers and text must match. Host-attached empty transcripts permit import, but nonempty transcripts still refuse overwrite.

Insert the clip from the Source Monitor at the playhead (insert edit). Experimental: a target clip spanning the playhead is QE-razored before insertion to attempt to preserve its split tail. By default the tool also razors and shifts every QE sync-locked track, then reads the placement and target tails back; a displaced tail is reported as committed_unverified. Pass scope 'target_tracks' to ripple only the named pair (this will desync other tracks).

Actions or modes: scope: sync_locked, target_tracks

Read available render and output-module template names from the first existing After Effects render-queue item. It never queues or renders a composition.

Inspect a saved After Effects source composition for MOGRT-relevant dimensions, duration, text fonts, layer-source kinds, and Essential Graphics controller names when the host exposes the AE 16.1+ readback API. It never creates a composition or returns asset paths.

Inventory native caption tracks on the active sequence through documented Premiere UXP APIs. Returns track identity, name, mute state, and item count only; it does not inspect cue text, timing, rendered appearance, or caption correctness.

Parse a local CMX 3600 EDL into bounded event, reel, track, transition, and timecode facts without importing it into Premiere.

Inspect a Premiere Pro DOM object and list its properties, methods, and values. Useful for exploring the API and debugging. object_path must be a property path starting with app or qe (identifiers and numeric indexes only). Function calls, operators, and statements are rejected; use evaluate_expression with unsafe-script for those. Examples: - "app.project" → project properties - "app.project.activeSequence" → sequence properties - "app.project.activeSequence.videoTracks[0].clips[0]" → first clip on V1 - "app.project.activeSequence.videoTracks[0].clips[0].components[0]" → first component of a clip

Audit the active sequence in one read-only bridge request for empty timelines, primary-track gaps, disabled clips, muted tracks, and excessive Motion scale. Structural diagnostics only; it cannot judge story, framing, sound, or final delivery.

Inspect the bounded native descriptor catalog for one effect component on one active-sequence audio or video clip. The returned parameter index and display name can be used with existing parameter automation. It returns only animation capability/state, never raw parameter values (including Color or PointF), media paths, rendered pixels, or playback results. The bridge reads the complete catalog twice and rejects a changed project, active sequence, component identity, or parameter descriptor set.

Actions or modes: media_type: video, audio

Inspect a local FCPXML or FCP7 XML (xmeml, what Premiere's export_as_fcp_xml writes) document: format, version, sequence/clip counts, bounded media declarations, and text-only parser warnings, before deliberate Premiere import.

Validate a revision-bound film editorial manifest against captured source and timeline identities. Build complete declared coverage review groups, independent picture/audio preferences, screening-note exceptions, story dependencies, VFX state, change impact and a department turnover manifest. Local inspection only: no host edits, exports, automatic creative decisions or verified host claims.

Use Premiere's documented native TickTime and FrameRate APIs to either align one bounded requested time down or to the nearest frame boundary, or construct the exact TickTime for one frame count. This is read-only, uses only caller-owned inputs, and returns native seconds and tick-string readback; it does not inspect a sequence, infer its frame rate, change Premiere, or prove a licensed host.

Actions or modes: align, frame

Inspect whether Premiere exposes its documented installed MOGRT directory. The native path is redacted unless include_path is explicitly true. This tool never enumerates the directory, reads its files, imports a template, or changes Premiere; a returned path is not proof that templates are usable or compatible.

Read caller-selected artifact bytes, hash them and identify actual OTIO/FCP7 xmeml/FCPXML/EDL structure. AAF/OMF are bounded opaque-byte evidence only. File existence, parsed structure, round-trip and licensed-host/destination evidence remain distinct.

Actions or modes: format: otio, fcp7xml, fcpxml, edl, aaf, omf

Build per-feature inspected/approximated/dropped/unknown loss evidence for OTIO, FCP7 XML, FCPXML, CMX EDL, AAF or OMF. Optional artifact inspection identifies its actual root. Source inventory is caller evidence; this never infers destination acceptance from exporter success.

Actions or modes: format: otio, fcp7xml, fcpxml, edl, aaf, omf

Inspect a local media file with ffprobe and return container, stream, codec, time-base, channel, and chapter metadata. Read-only and independent of Premiere.

List bounded top-level template names and version directories in an existing workspace-contained local MOGRT library. It never reads MOGRT contents or changes the library.

Inspect unknown execution outcomes and a bounded current host-state revision. Inspection remains available while dependent mutations are blocked. No edit is replayed.

Actions or modes: backend: cep, uxp

Parse a bounded local OTIO Timeline.1 into exact-tick offline tracks/clips/gaps/transitions. Reports missing media, opaque nests/effects/metadata and unsupported timing. Synthetic IDs never authorize Premiere writes; this tool never imports a project.

Inspect After Effects interoperability and the active Premiere project's current and supported graphics-white luminance values through documented read-only UXP APIs.

List or briefly wait for bounded, redacted Premiere host-event receipts without polling the complete project state. Compatible hosts can also emit timeline.snap.* receipts plus operation.clip.extend.reached and coalesced operation.effect.drag.over receipts for documented root notifications; raw event payloads are never returned.

Actions or modes: list, wait

Read the current Project-panel insertion bin through documented Premiere UXP APIs. Returns only the active-project GUID and insertion-bin ID, name, and type; it does not traverse project folders, reveal media paths, or change Premiere. The panel target is read twice and the command rejects a project or target change while snapshotting.

Inspect a project item's documented effective/original color space, LUT IDs, available color-space overrides, and audio channel shape.

Read bounded native Project-panel metadata: panel layout XML, or one media item's visible columns as JSON (ColumnName, ColumnValue, ColumnID, ColumnPath). Column JSON is the current view, not every XMP namespace. This is read-only; it neither creates schema fields nor writes Project-panel state.

Actions or modes: panel, item_columns

Read-only recovery inspection: diagnose the active project path and list adjacent Premiere Auto-Save project candidates without opening, copying, or restoring anything.

List Premiere Project-panel views or inspect up to 256 selected project items without traversing the complete project tree.

Actions or modes: views, selection

Read a bounded, depth-limited native Project-panel tree rooted at the active project. Returns stable IDs, names, types, parent IDs, bin state, and optional color-label indexes only; it never returns media paths, metadata, or rendered media. Items without a stable ID are skipped rather than failing the whole tree.

Read a compact, revisioned project and sequence snapshot through documented Premiere UXP APIs.

Sample a caller-owned exported video using existing decoded RGB scopes and declare range/transfer/primaries evidence. Refuses HDR legal-range claims from an 8-bit RGB proxy; does not prove Premiere render lineage.

Actions or modes: color_range: limited, full, unknown

Inspect documented audio, tone-mapping, linear-compositing, bit-depth, render-quality, and display settings for the active sequence.

Build one read-only sequence handoff report with timeline structure, primary-track gaps, disabled clips, muted tracks, marker timing, and offline-source evidence. Media paths are never returned; marker comments require an explicit opt-in. It does not prove rendered pixels, audio quality, caption correctness, rights, or editorial approval.

Read a bounded native UXP timeline structure for one sequence: selected video and/or audio tracks with clip timing and state. Opt in to source Project-item IDs only when needed, then optionally classify those sources as sequence, merged, multicam, or offline or return their documented broad content category (any, sequence, or media); a further opt-in returns only a nested source sequence GUID when that classification is exactly sequence. No Project-panel metadata, names, type codes, paths, nested timeline content, or traversal are read. track_counts contains only the requested media types, never a zero placeholder for an unqueried type. The response is capped at 64 tracks and 512 items, omits components, rendered pixels, audio analysis, and caption cues, and is not a locked cross-object snapshot or proof of playback or editorial correctness.

Actions or modes: media_type: all, video, audio

Read one known sequence's bounded native timing and backing Project-item identity, including a non-active sequence without activating it. It resolves the exact GUID through the documented Project API, requires a matching project/sequence identity after the asynchronous reads, and rejects any timing change between complete first and final snapshots. It does not modify Premiere, prove an atomic host snapshot, or validate a licensed host.

Read the active sequence's native frame size, timebase, audio/video time-display codes, and backing Project-item identity. The command rejects malformed host values or a final active-sequence mismatch; it does not modify Premiere, claim a locked snapshot, or detect a transient switch that returns to the same active sequence.

Read selected documented source-media provenance paths for one explicit media-backed Project item. At least one explicit include flag is required before either native path is queried or returned. The command resolves the requested item through a bounded Project-item tree twice and rejects a changed project, target item, or requested path; it does not enumerate folders in its response, access the filesystem, inspect media contents or metadata, validate a path's existence, modify Premiere, prove an atomic snapshot, origin lineage, rights, persistence, or licensed-host behavior.

Read documented proxy-readiness state for one explicit media-backed Project item. Proxy attachment state, offline state, and native capability booleans are read twice through a bounded Project-item tree; a native proxy path is queried and returned only when include_proxy_path is true and a proxy is reported attached. The command rejects changed project, target, or selected proxy state. It does not enumerate folders in its response, does not access the filesystem, validate a path's existence, inspect media contents, attach or relink proxy media, modify Premiere, prove an atomic snapshot, proxy compatibility, playback, persistence, Undo, or licensed-host behavior.

Read Warp Stabilizer presence, exposed status properties, and conservative analysis state for one clip or every video clip in the active sequence. Read-only: unknown or localized host values remain unknown rather than being reported as solved.

Inspect one exact CEP sequence into version1 canonical snapshot preserving raw tick strings, source/link identities, bounded clips and explicit unknown fields. Host missing lock/effect/transition/marker state remains incomplete; this inspection never implies atomic host state. Re-query from zero after change or truncation.

Inspect one active-sequence clip's native match name, item type, media UUID, reported track index, and selection state through documented UXP APIs. It rechecks the active sequence identity before returning and does not expose media paths, effect parameters, or rendered output.

Actions or modes: media_type: video, audio

Read the opaque documented Premiere unique serializable identity for exactly one existing project item or sequence, without changing the project. Select exactly one locator. The bridge independently resolves and reads the target twice, rejecting an active-project, locator, or unique-identity change rather than returning a mixed snapshot. It does not expose paths, metadata, content, timeline placement, editability, rendering, playback, persistence guarantees, or a licensed-host result.

Read one bounded native video-transition target, including the active sequence GUID, source item ID, timeline edges, and presence at one requested edge. Copy this snapshot unchanged into add_video_transition_uxp or remove_video_transition_uxp.

Actions or modes: position: start, end

Read one private saved workflow checkpoint after restart. Unsupported versions reject; pending and unknown operations require reconciliation. Loading never dispatches mutations or restores projects.

Inspect exact local or UXP job identity. Host terminal events do not verify an output artifact; an absent job is unknown, never completed.

Actions or modes: origin: local, uxp

Invert the current clip selection in the active sequence (selected become deselected and vice versa).

Check if a transcript language pack is available through documented Premiere 26.3+ UXP APIs. This is a read-only availability check; it does not download language packs or change Premiere.

Check whether the work area bar is enabled on the active sequence

EXPERIMENTAL (undocumented QE DOM: the sequence lift command, exposed as left() on 25.2). Lift (remove without closing the gap) the content between the sequence in/out points on every targeted, unlocked track, then verify the range is empty on those tracks and nothing else on them moved. Marks that Premiere stored just off a frame are first re-written on that exact frame through QE (marksRewritten). Requires sequence in/out marks that do not span the whole sequence. Untargeted tracks are not verified; any that changed are listed in otherTracksChanged.

Lift the current timeline selection through Premiere's documented UXP SequenceEditor. This removes selected items without ripple in one undoable transaction; transaction acceptance is not a timeline readback.

Link the currently selected video and audio clips in the active sequence, then read the links back. Needs at least two selected clips; verified only when every selected clip is linked to every other.

List all available audio effects in Premiere Pro. Uses QE DOM.

EXPERIMENTAL (undocumented QE DOM): List audio transitions. Reports an unavailable or empty legacy catalog as an error rather than an assumed usable list.

List available video effects in Premiere Pro. Uses the full QE catalog when exposed; otherwise returns a verified, explicitly partial set of common effects resolved by exact name.

EXPERIMENTAL (undocumented QE DOM): List video transitions. Returns a built-in hint set on PPro 2026 where the registry list is empty even though by-name lookup works; the hint set is not exhaustive.

List effects/components exposed by the clip's standard DOM collection, with properties and current values. Some hosts omit QE-applied effects from this collection; absence here does not prove an effect is absent. get_effect_properties uses the same collection. Inspect Premiere's Effect Controls UI when complete QE effect presence must be confirmed.

List markers on the active sequence, or on a source project item that exposes a marker collection, including marker GUID and color when readable. A timeline-clip node_id returns a clean error instead of a raw TypeError.

List Premiere markers with stable 26.3+ GUIDs from the active sequence or one source media clip. Web-link URLs/frame targets and raw marker RGBA components are returned only with explicit opt-in; URLs can contain sensitive query data, and color components are host values without a color-profile or rendered-appearance claim.

Actions or modes: scope: sequence, project_item

List all items in the project panel (clips, bins, sequences)

List '[checkpoint]' sequences created by create_sequence_checkpoint, optionally only those cloned from one sequence, with their labels, timestamps, track and clip counts. Read-only.

List all tracks (video and audio) in a sequence

List all sequences in the project

List the Essential Graphics title templates that ship with the installed Premiere Pro (Basic Title, Lower Thirds, Credits, Social Media, and more), with each template's text fields in order and their default text. Reads the local .mogrt files only; does not contact Premiere. Use the names with add_title.

List the installed native video-transition match names from the connected Premiere UXP host.

Set a video track's lock state and read it back to verify the change.

Inspect up to 64 source media items, refresh them serially, transactionally set them offline, or find project items matching an approved media path. Native paths are redacted unless explicitly requested; opt-in media timing is read-only, bounded, and runtime-compatible.

Actions or modes: inspect, refresh, set_offline, find_by_media_path

Create an undoable J-cut or L-cut by extending one aligned 1x audio item while preserving source sync, with atomic UXP actions and edge/source readback.

Actions or modes: kind: j_cut, l_cut

Inspect or explicitly set one of Premiere's three documented AppPreference keys. Setting is a direct, non-undoable application-state change: copy the native string returned by inspect, choose persistence deliberately, confirm the change, and provide an operation_id for replay-safe dispatch. Competing writes to the same named preference serialize and are read back exactly.

Actions or modes: inspect, set

List native audio/video effects, inspect one clip's component chain, or add/remove one effect in a locked Premiere UXP transaction. Mutation verification covers the component chain only; inspect playback or exported output to confirm rendering.

Actions or modes: catalog, inspect, add, remove

Preflight project graphics-white/LUT/footage interpretation state, or update bounded footage-conformance fields in one undoable UXP transaction.

Actions or modes: preflight, update

Inspect, pause under a bounded lease, or resume Premiere growing-media swaps. Pause expires within ten minutes and is resumed on ordinary panel or bridge shutdown; status is panel-local and never claims a host readback.

Actions or modes: status, pause, resume

Inspect, add, update/move, remove, or explicitly review-then-remove a bounded marker batch by stable GUID using documented, undoable Premiere actions; mutations for one marker owner are serialized through preflight and readback.

Actions or modes: inspect, add, update, remove, remove_many

Start, inspect, rescan, or stop one session-scoped local media-folder monitor. It records bounded file-change signals and never imports media automatically.

Actions or modes: start, status, scan, stop

Read bounded project/XMP metadata, inspect named fields from column JSON and XMP, or update one field/packet together in a locked undoable Premiere transaction with readback. Prefer inspect_fields or item_columns before requesting full XML. GPS and camera serials are omitted unless include_sensitive is true.

Actions or modes: get, update, inspect_fields, update_field

Capture, enrich, import revision-bound editorial evidence, inspect, or clear a durable local Premiere project-context index. Capture stores bounded active-sequence/source metadata; local enrichment and evidence import add caller-approved transcripts, speaker labels, shots, audio observations, notes, or opaque frame references without re-analyzing media. Never include secrets or unrelated customer data.

Actions or modes: capture, enrich, import_evidence, status, clear

Inspect or guardedly replace native Project-panel metadata. Update requires the exact inspected project GUID and XML, explicit confirmation, a replay key, local per-project serialization, and exact native readback; Premiere does not expose an atomic compare-and-set for this direct non-undoable setter.

Actions or modes: inspect, update

List or explicitly create, open, save, branch, and close Premiere project sessions. Path writes stay inside the approved UXP workspace; Save As handle changes are read back and branch copies reopen the source after every copy.

Actions or modes: list, validate, create, open, save, save_as, branch_copies, close

Create or attach proxies for a project item, or set Premiere's proxy display. 'toggle' is application-wide, not per item: it changes app.getEnableProxies()/setEnableProxies() for every sequence and monitor, and item_id is only checked to exist. Pass enabled: true or false to set a known state; omitting enabled flips the current state, so two calls undo each other. The result reports previousEnabled and proxiesEnabled read back from Premiere. Note: 'create' only requests a proxy encode from Adobe Media Encoder and returns an unverified handoff. Independently verify the AME queue or output file before calling this tool again with action 'attach' and proxy_path set to the output_path you passed here. Optional start_batch requests processing of every ready AME queue job, including unrelated jobs. There is no single-call create-and-attach in Premiere's ExtendScript API.

Actions or modes: create, attach, toggle

Inspect or attach proxy/high-resolution media for one clip, or read/update project ingest state. Attach operations are non-undoable and workspace-contained.

Actions or modes: inspect_proxy, attach_proxy, get_ingest, set_ingest

Inspect or update a sequence's native audio/video time-display formats. Updates require the exact inspected sequence GUID and complete display-format snapshot, serialize competing updates per sequence, commit one undoable UXP transaction, and verify native readback. Cancellation is not supported after dispatch.

Actions or modes: inspect, update

Inspect or set the active sequence player position through documented Premiere UXP APIs. Setting requires the sequence GUID and current position returned by inspect, serializes competing requests for that sequence, and verifies native readback; it changes player state only and makes no project-save or Undo claim.

Actions or modes: inspect, set

Inspect or set one explicit sequence's documented preview-frame rectangle. Update requires the complete inspected snapshot, explicit confirmation, and an operation ID; it serializes preview-frame updates by reviewed project and sequence, commits one undoable settings transaction, then reads the same sequence back. It does not set sequence video dimensions, alter media or exports, prove rendered preview output, persistence, Undo behavior, or coordinate with Premiere UI or other extensions between native calls.

Actions or modes: inspect, update

Inspect or update the active sequence's in, out, and zero points through documented Premiere UXP actions. Updates require the complete inspect snapshot, run in one undoable transaction, and return native readback; a runtime capability probe remains authoritative.

Actions or modes: inspect, update

Inspect sequence settings or apply a bounded settings profile in one documented, undoable UXP transaction with readback.

Actions or modes: get, update

Inspect, create-from-media, clone, derive, activate, open, close, or explicitly delete sequences through documented stable UXP APIs. Each action accepts only its own parameters: inspect takes none and lists every sequence; clone/subsequence/activate/open/close/delete take sequence_id; create_from_media takes name and project_item_ids.

Actions or modes: inspect, create_from_media, clone, subsequence, activate, open, close, delete

Inspect or transactionally update source-clip in/out points and request scale-to-frame for up to 64 media items. In/out values are read back; Adobe exposes no getter for clear or scale state, so those requests remain committed-unverified.

Actions or modes: inspect, update

Inspect or transactionally set one source media item's explicit frame-rate and/or pixel-aspect-ratio override through stable Premiere 26.3 UXP actions. Updates require the complete effective-interpretation snapshot, explicit confirmation, an operation_id, per-item serialization, one undoable transaction, and native effective-value readback. Premiere does not expose an override-presence getter, so this tool cannot clear or distinguish an explicit override from matching file-native interpretation.

Actions or modes: inspect, update

Inspect or transactionally set one source media item's timecode start through stable Premiere 26.3 UXP APIs. Setting requires the exact bounded timing snapshot, explicit confirmation, one undoable transaction, per-item serialization, and native readback.

Actions or modes: inspect, set_start

Inspect, replace, add to, remove from, or clear the active sequence's native UXP clip selection with sequence and clip fingerprint stale-state guards.

Actions or modes: inspect, inspect_targets, replace, add, remove, clear

Inspect or set the documented source Project-item color label resolved from one audio or video timeline coordinate in the sequence named by sequence_id (inspect falls back to the active sequence only when sequence_id is omitted; update always targets expected_snapshot.sequence_id). Update requires the complete reviewed snapshot, explicit confirmation, and an operation ID; it serializes color-label changes by source item, commits one undoable transaction, then re-reads the coordinate and source label. A source label is project-global: another use of the same source can reflect the change. It does not label a timeline-only instance, change clip timing, prove rendered appearance, playback, persistence, or Undo behavior.

Actions or modes: inspect, update

Inspect audio, video, and caption track mute state or set one media type serially with stale-state preflight and per-track readback. Adobe exposes this as direct promises, so no undo transaction is claimed.

Actions or modes: inspect, set_mute

Inspect or set the active sequence work area through Premiere 26.5+ documented UXP WorkAreaUtils. Setting requires the sequence GUID and complete work area returned by inspect, keeps out within the sequence end, serializes competing requests, and verifies native in/out readback. WorkAreaUtils is a direct call, not an undoable transaction; a runtime capability probe remains authoritative and live-host behavior is not yet verified.

Actions or modes: inspect, set

Read or transactionally write small, namespaced workflow checkpoints on the active project or a targeted sequence. Persistent values may sync with cloud projects; never store secrets, native paths, transcripts, or media names.

Actions or modes: has, get, set, clear

Translate source, clip-relative and sequence ticks from an inspected snapshot. Warns outside visible range; refuses nested, reverse or retimed clips until a measured mapping exists. No keyframe write or rendering claim.

Actions or modes: domain: source, clip_relative, sequence

Read-only mapping from source-media time ranges to placements on one sequence track. Reads the selected track once, maps only normal-speed forward clips, reports source portions not present on the track as unplaced, and returns bounded pages. This inspects timeline placement; it does not prove rendered or audible content.

Actions or modes: track_type: video, audio

Map revision-bound transcript words to every forward1x source placement, with occurrence IDs and exact snapshot placement ticks. Refuses missing pages, nonlinear retiming, reverse and ambiguous nests.

Get source media info for the frame at the current playhead on a specific track. Useful for match frame operations.

Actions or modes: track_type: video, audio

EXPERIMENTAL (undocumented QE DOM for track changes): Move a clip to a new position on the timeline; optional track moves use Premiere's QE API and may not work on every version.

Move a clip to a different track of the same type, keeping its start, duration, and source in/out. EXPERIMENTAL: uses the undocumented QE DOM moveToTrack. Refuses without changing anything when the origin or destination track is locked or the destination range is occupied. Reads the timeline back: verified only when the clip is on the destination track with the same span and source range and is gone from the origin track; committed_unverified when the source range cannot be read; otherwise failure with Undo guidance.

Move a project item to a different bin and confirm where it landed

Move multiple project items to a target bin at once.

Move the playhead to the next or previous edit point.

Actions or modes: direction: next, previous

EXPERIMENTAL (undocumented QE DOM: qe.project.undo / undoStackIndex). Undo several Premiere project actions through QE, checking each step against Premiere's undo-stack position (stackVerified; the timeline itself is not read back) and reporting how many were undone. Only actions Premiere records are undoable: QE edits such as razor, insert, lift and extract report undoSteps (and undoStackIndex) in their results; pass that undoSteps as count to reverse exactly that call. A marker receipt with undoTracked:false recorded no undo step: calling Undo for it would reverse an earlier action. Only CEP tool results carry undoSteps; UXP tools and workflows that send several commands are not counted. Always pass expected_undo_stack_index to check the stack position, but matching position alone does not prove which action is on top. Observed marker boundaries refuse the entire request before any step unless acknowledge_untracked_markers:true explicitly permits prior non-marker actions. The barrier persists through server/helper reloads while the CEP engine remains alive; it cannot account for marker writes before observation, after an engine reset, or through UXP, the manual UI, or other clients. Matching the QE index verifies stack position only.

Mute or unmute an audio track

Move the active-sequence playhead to the start, end, in/out point, work-area bound, next/previous edit or marker, or step a number of frames, then read back the resulting position. Navigation only; it never changes clips.

Actions or modes: start, end, in_point, out_point, work_area_in, work_area_out, next_edit, previous_edit, next_marker, previous_marker, step_forward, step_backward

Unavailable on the legacy CEP backend: Premiere's documented createSubsequence API only creates a separate sequence and cannot safely replace the selected timeline clips with a nested-sequence reference.

Create a new loudness-normalized media derivative with FFmpeg, then remeasure that exact output using EBU R128. Never overwrites the input or an existing output file.

Open a project item in the Source Monitor for preview and trimming, and confirm it is the clip now showing.

Open a Premiere Pro project file and make it the active project, verifying it is open. Other open projects stay open.

Inspect a bin or transactionally create, rename, move, color-label, and remove project items with stable-ID guards. Remove requires project_item_id (it never uses the Project panel selection) and verifies the item is gone from the project tree.

Actions or modes: inspect_bin, create_bin, create_smart_bin, rename, move, set_color, remove

Overwrite a project item onto validated timeline tracks and verify a new source placement at the requested time

Overwrite the clip from the Source Monitor at the playhead position (overwrite edit — replaces existing clips) and verify a new placement on the requested tracks.

Paste Attributes for one timeline clip: copy the source clip's effect stack (Motion, Opacity, other intrinsic components, and every applied effect) onto a target clip of the same track type, including keyframes. Components are matched by match name and occurrence; a missing non-intrinsic effect is applied through the experimental legacy QE DOM (disable with apply_missing_effects=false). Every written parameter and keyframe value is read back and reported per property as verified, committed_unverified, or failed, with an overall status. Not copied, and listed in notCopied with a reason: parameters whose values ExtendScript cannot read as numbers, booleans, strings, or numeric arrays; Opacity > Blend Mode when it differs (legacy cross-clip enum writes can corrupt it; use set_blend_mode and verify); and keyframe interpolation (no getter exists, so pasted keys use Premiere's default interpolation). MASKS ARE NOT COPIED: neither ExtendScript, QE, nor documented Premiere UXP exposes mask shapes, paths, feather, expansion, or mask keyframes, and masks are invisible to this bridge, so recreate or paste masks manually in Effect Controls. Time Remapping is excluded unless named in components.

Health check — verify the CEP plugin is running and connected to Premiere Pro. Call this before other tools to confirm connectivity.

Plan an active-speaker vertical reframe (Motion Scale/Position keyframes that follow whoever is talking) or a static stacked/split layout from a word timeline and static speaker regions. Returns framings, switches, keyframes, and apply routes. Local-only; never changes Premiere.

Actions or modes: layout: active_speaker, stacked, split_left_right, auto

Preview a bounded AAF/OMF audio-post turnover contract: exact exclusive range, handles, rational rate, channels, requested gain automation, media hashes and reference picture. Routes to existing native exporters. Caller manifests and exporter settings are not DAW acceptance or audible-alignment proof.

Actions or modes: format: aaf, omf; sample_rate: 44100, 48000, 88200, 96000, 192000; gain_automation: preserve_requested, render_requested, unsupported

Plan a beat-synced montage: carve a detect_beats grid into shots every N beats (merging short and splitting long spans), assign clips in order, and emit add_to_timeline_batch chunks, trim ranges, and cut markers. Local-only and deterministic; never changes Premiere.

Actions or modes: order: as_given, priority, round_robin

Plan YouTube-style chapters from a word-timed transcript using local TextTiling-lite topic-shift detection, titling each chapter from its distinctive tokens. Returns chapters, a youtube_timestamps block and add_marker-ready Chapter markers. Local-only plan; never changes Premiere.

Turn pasted client or reviewer feedback into a prioritized checklist: finds timecodes and ranges, classifies each note (audio, color, graphics, text, timing, cut, legal, delivery), infers must/should/nice priority, separates approvals and questions, and emits an add_markers_batch payload. Local-only and deterministic; never changes Premiere.

Actions or modes: timecode_style: auto, clock, frames; marker_color_mode: priority, category, fixed

Plan an After Effects MOGRT or rendered-file handoff to Premiere using existing tools. Returns ordered dependencies, separate approvals, required evidence, and manual render stops. Local-only planning; never executes steps, issues approval tokens, or claims host readiness.

Actions or modes: workflow: ae_mogrt_to_premiere, ae_render_to_premiere

Plan CapCut-style punch-in zoom keyframes (Motion Scale + subject-anchored Position) from a word timeline or supplied trigger times, with cooldown, easing, and hold controls. Local-only and deterministic; returns a keyframe plan for automate_effect_parameters_uxp or add_keyframe and never changes Premiere.

Actions or modes: trigger: sentence_start, emphasis_words, every_n_seconds, supplied

Plan word-level filler removal (um, uh, you know...) from a revision-bound word timeline. Hesitation-sound removal requires a transcript that preserves disfluencies, such as Premiere transcription or verbatim ASR; Whisper's default output omits them. Returns frame-snapped removal and keep ranges plus apply routes. Local-only; never changes Premiere.

Plan synchronization locally from bounded normalized mono PCM correlation or caller-matched marker/timecode tick anchors. Returns confidence, ambiguous alternatives or silent/noise refusal. Placement offset application is separately reviewed.

Actions or modes: method: audio, anchors

Plan active-speaker camera switching for stacked, synced camera tracks: from speaker segments and a camera-to-speaker map it produces an angle cut list with minimum holds, crosstalk cover shots, optional lead-in cuts and periodic cutaways, plus razor times, per-camera enable/disable ranges, and markers. Local-only and deterministic; never changes Premiere.

Plan deterministic music shortening from an approved measured beat grid, protected intro/outro and crossfade handles. Returns exact segments and nearest-beat error for audible review. No DSP render or native Premiere Remix control.

Plan shortening (not deleting) of inter-word pauses longer than max_pause_seconds down to a target, respecting sentence boundaries. Returns centered removal ranges, keep ranges, savings and apply routes. Local-only; never changes Premiere.

Plan multi-ratio delivery of one source sequence to TikTok, Reels, Shorts, YouTube, LinkedIn, X, and Facebook from a local spec table: sequence settings, reframe scale math, duration and file-size fit, caption safe zones, and ordered apply routes. Local-only; never changes Premiere.

Actions or modes: strategy: auto_reframe, pad_blur, center_crop, letterbox

Plan stacked, speaker-colored reaction captions from a word timeline and an explicit speaker palette. Flash-length words merge, overlaps stack, and unknown speakers stay uncolored. Local-only; never changes Premiere.

Turn reviewed source scene candidates into exact nonoverlapping segments with bounded source handles, rejected-candidate report and existing marker/subclip/bin routes. Detection never edits source; linked audio is preserved in the plan.

Plan a series-named export folder inside an approved Shorts root and remind the caller to create it when missing. Local-only; never writes files or changes Premiere.

Actions or modes: brand: watch_club, cafe, other

Plan a brief subscribe overlay about two-thirds through a Short, after an optional hook, in a platform-safe lower-third. Local-only; never changes Premiere.

Actions or modes: brand: watch_club, cafe, other; platform: tiktok, instagram_reels, youtube_shorts, instagram_feed, youtube, linkedin, x

Compare two bounded local-media frame samples and return measured waveform/parade/saturation deltas plus coarse correction directions. Read-only planning only; it does not grade Premiere or claim that primaries alone can match the shots.

Create a bounded, non-mutating review plan that maps FFmpeg-detected source-media silences onto one known 1x timeline placement. It clips candidates to the supplied source in/out span, redacts the source path, and never adds markers, cuts clips, or changes Premiere.

Plan a speaker checkerboard (each speaker's turns on their own video/audio track) from a caller-supplied word timeline. Returns frame-snapped segments, split points, track assignments, and the add_track/razor_all_tracks/move_clip_to_track routes. Local-only; never changes Premiere.

Build a revision-locked, non-mutating rough-cut plan from Premiere's native transcript and verified 1x sequence placements. The plan orders cuts from the end of the timeline, requires a duplicate sequence, and requires re-query after every mutation.

Plan mute or bleep ranges for listed words/phrases in a word timeline. Returns redacted, frame-snapped mute ranges, ready-to-apply audio keyframes and (for bleep) tone placements. Local-only; never changes Premiere.

Actions or modes: mode: mute, bleep

Request playback of the clip in the Source Monitor. Fails when no clip is loaded. The legacy API does not provide a same-call position readback, so movement is not reported as verified.

Request playback of the active sequence timeline through QE. The legacy API does not provide a same-call playhead readback, so movement is not reported as verified.

Predict exact affected clips for a conservative supported insert/overwrite/trim/split/move/remove/ripple/enable subset using complete canonical state. Refuses unknown locks, links, source handles and retiming. Local prediction does not execute Premiere or promise native edit semantics.

Inspect project/Production scratch disks and ingest state, or set supported project scratch categories to Premiere's symbolic destinations in one undoable transaction.

Actions or modes: preflight, configure_project

Inspect native UXP transcript readiness before optionally starting Speech-to-Text once per operation. Returns accepted/pending/ready/failed/unknown with revision, never transcript completion from start acceptance. No CEP fallback; Adobe privacy/service preferences apply to explicitly confirmed start.

Preview a bounded queue-only After Effects render request for one named composition and existing workspace output directory. It does not contact Adobe, enqueue, or render.

Preview import of one completed After Effects single-file render into an existing Premiere bin. Reads both connected hosts and binds approval to file metadata and project/bin identity. Does not render, import, or edit a timeline.

Preview a brand-spot assembly from existing project items with an optional workspace-contained MOGRT overlay. Preview is local-only; it does not read or import the MOGRT file.

Actions or modes: motion_style: none, push_in, pull_out, alternate

Validate transcript revisions and preview a talking-head or speaker-reviewed podcast derivative. It creates nothing and returns an exact confirmation token.

Actions or modes: mode: talking_head, podcast

Inspect sequence, project item, clip and requested track targets before previewing a compound timeline edit without changing Premiere. Returns a single-use confirmation token bound to stable project, sequence and target identities; it expires after 30 minutes and is required by apply_edit_plan.

Revalidate an exact server-issued editorial plan against the saved project-context revisions and return an opaque confirmation token. This tool is read-only and cannot apply the plan.

Preview up to100 distinct bound CEP targets for supported trim, experimental QE split, same-track move, enable, scalar effect and keyframe steps. All targets and descriptor identities validate before token issuance; unsupported links/retiming/unknown source handles refuse. Requires exact saved project path and active sequence. No mutation or atomicity claim.

Read a bounded ALE table and preview explicit column-to-named-field mappings against reviewed source IDs/filenames. Reports duplicate table keys, ambiguous filenames, missing sources and unsupported fields. Never writes Premiere metadata or requires an XMP packet dump.

Preview up to 20 bounded MOGRT recipe exports from a workspace-contained JSON or CSV data file. It does not contact Adobe or create any compositions or files.

Preview a no-overwrite publish of a validated MOGRT into a workspace-contained, versioned local library. The library root must already exist; no file or directory is created during preview.

Preview a contained MOGRT import into one explicitly named disposable Premiere verification sequence and empty video track. It does not contact Premiere or alter a sequence.

Preview a bounded After Effects MOGRT recipe from the supported title, callout, quote, social, and media-placeholder template library. It validates one existing workspace output directory but does not contact Adobe or write any files.

Actions or modes: recipe: lower_third, title_card, callout, quote_card, social_end_card, media_placeholder; frame_rate: 23.976, 24, 25, 29.97, 30, 50, 59.94, 60; text_controls: full, text_only

Preview a contained motion-graphics demo assembly from existing project items. It never creates demo assets, imports files, creates a sequence, or changes Premiere; apply requires an exact confirmation token.

Serialize the declared bounded linear offline snapshot subset to OTIO, then parse it back and compare exact supported structure. Refuses unsupported nests/effect parameters/non-frame timing. Returns text for review; does not write files or establish Premiere/destination compatibility.

Preview a product-spot assembly from existing project items. The eventual apply is limited to explicit empty tracks, revalidates item IDs, and reports host readback without claiming visual delivery verification.

Actions or modes: motion_style: none, push_in, pull_out, alternate

Inspect a bounded Premiere project against an explicit facility intake template and return a path-redacted report plus a non-mutating organization proposal. It never changes Premiere or persists the template.

Preview reviewed scene candidates against one exact CEP source and measured physical media duration. Binds project document/source path, explicit marker/subclip mode and destination bin name. No mutation; flashes/pans/fades remain in review evidence rather than automatic cuts.

Actions or modes: mode: markers, subclips, both

Preview exact enable states for pre-razored ordinary stacked camera clips and preserve master audio. Refuses unreviewed cuts, retiming/nests, missing lock/link state. Apply creates a duplicate sequence first; no native multicam switch API is claimed.

Validate and merge source-time ranges selected from Premiere's native transcript. Returns a confirmation token and never changes the timeline. Automatic timeline application remains withheld until the source-to-sequence mapping is live-host verified.

Compare the active watch baseline with a fresh contained scan and return a path-redacted import proposal. It never imports or changes Premiere.

Validate and expand one declarative workflow recipe into guarded MCP routes. It does not invoke any route or change Premiere.

Publish the exact previewed MOGRT as an immutable local-library version. Requires explicit confirmation and will fail instead of replacing an existing version.

Rank long-video transcript windows as short-form clip candidates using explainable local heuristics (hook, completeness, density, supplied evidence peaks, keywords, duration fit, speaker consistency) with overlap suppression. Local-only plan; not a virality prediction and never changes Premiere.

Razor (split) all clips at the playhead position across all tracks, or at a specific time. A read-only preflight counts eligible track cuts; the host wait scales by that count (400 ms per cut plus 30 seconds headroom, capped at 15 minutes).

Actions or modes: track_type: video, audio, both

Diagnose whether the active Premiere scripting host can enumerate caption tracks. It never treats an empty result as proof that the sequence has no captions, because most CEP builds expose caption creation but not caption reads.

Read waveform percentiles, RGB parade percentiles, saturation, and near-black/near-white RGB occupancy from one bounded decoded local-media frame. Read-only; this is a sampled analytical proxy, not Premiere's rendered scopes.

EXPERIMENTAL (undocumented QE DOM: qe.project.redo / undoStackIndex). Redo the most recently undone Premiere project action(s) through QE, checked step by step against Premiere's undo-stack position (stackVerified; the timeline itself is not read back). To restore a tool call undone with undo, pass the same count. Observed marker boundaries refuse before any step; acknowledge_untracked_markers:true permits prior non-marker actions, without proving marker reversal.

Refresh a project item to pick up changes to the source file. The interpreted frame rate is read before and after; if the refresh leaves an implausible rate (seen on stills, e.g. 29.97 becoming 2.75e-8), the previous rate is restored and read back. Reports frameRateBefore, frameRateAfter and repaired.

Legacy CEP relink can block Premiere indefinitely, even for an existing file on Premiere 26.5.2. Prefer relink_offline_media_uxp, which checks capability and reads the result back. This CEP route refuses by default; allow_unsafe_cep_relink must be explicitly true to attempt it, and its result is never reported as verified.

Relink one offline clip to a workspace-contained media path after stale-path and capability checks. This Premiere API is non-undoable and requires explicit confirmation.

Remove every effect from a clip, keeping its built-in components (Opacity, Motion, Volume, Channel Volume, Panner), and verify the result. EXPERIMENTAL: when Premiere has no Component.remove() (25.2), it removes through the undocumented QE DOM's targeted qeClip.getComponentAt(i).remove(). Every matching component's removal path is checked before any is removed; it returns a capability error, with nothing changed, when neither path is available.

Remove one effect from a clip by its index or name (the last instance when names repeat) and verify the clip's components afterwards. Built-in components (Opacity, Motion, Volume, Channel Volume, Panner) cannot be removed. EXPERIMENTAL: when Premiere has no Component.remove() (25.2), it removes through the undocumented QE DOM's targeted qeClip.getComponentAt(i).remove(). Every matching component's removal path is checked before any is removed; it returns a capability error, with nothing changed, when neither path is available.

Remove all instances of a specific effect from a clip by display name and verify the clip's components afterwards. EXPERIMENTAL: when Premiere has no Component.remove() (25.2), it removes through the undocumented QE DOM's targeted qeClip.getComponentAt(i).remove(). Every matching component's removal path is checked before any is removed; it returns a capability error, with nothing changed, when neither path is available.

Remove a clip from the timeline. By default its linked audio/video partners go with it, as with Premiere's Clear on a linked clip. With ripple: true the gap is closed through the same explicit, verified ripple delete as ripple_delete (Premiere's own ripple flag does nothing on current builds), shifting sync-locked tracks so audio stays in sync.

Remove the keyframe at a time from an effect property and read the remaining keys back. Refuses, changing nothing, when no key is within 0.01s of that time.

Remove every keyframe in a time range (inclusive) from an effect property and read the remaining keys back. Refuses, changing nothing, when the range holds no key.

Remove all currently selected clips and verify their absence. Ripple requests are refused because the CEP removal call cannot reliably close gaps; use a guarded ripple-range tool instead.

Remove one unchanged native video-transition edge through one undoable UXP transaction. Requires an exact inspect snapshot, serializes transition updates per sequence, and reads edge absence back; it does not prove rendered appearance or playback.

Actions or modes: position: start, end

Rename a bin (folder) in the project panel

Rename a clip on the timeline and verify the new name.

Rename a project item in the project panel.

Rename a video or audio track.

Actions or modes: track_type: video, audio

Rename an audio, video, or caption track through Premiere 26.3+ UXP in an undoable transaction with name readback verification.

Actions or modes: track_type: audio, video, caption

Replace one timeline clip with a different project item on the same track, keeping the exact timeline start and end. The replacement plays from its own In mark for the original clip's duration; neighbouring clips do not ripple, and a linked partner clip on another track is left in place. The replacement must carry only the track's media type (for example a still or video-only item on a video track): Premiere's overwrite would also place an item's other media on another track. Checks the replacement accepts the source range before removing anything. Refuses without changing anything when the track is locked. Reads the track back: verified when the new clip covers the same span, committed_unverified when the span holds but the source In point cannot be confirmed, otherwise failure with Undo guidance.

Unavailable by design: the legacy ExtendScript overwrite route cannot prove that replacing media preserves the original clip's trim, position, linked audio, or adjacent clips, so this tool performs no mutation.

Unavailable: Premiere does not expose a supported scripting API for reversing a timeline clip's playback direction.

Review caller-proposed owned-footage B-roll picks with matched quote, reason, alternatives, source/sequence revisions and explicit decisions. Reject overlapping approved placements. Does not infer visual content, search stock, inspect track occupancy or insert clips.

Review revision-bound dialogue candidates with surrounding words, silence padding, explicit keep/reject decisions and unioned source-time removal duration. Recomputed review revisions reject stale selections. Local-only; no timeline mapping, transcription or mutation.

Review a transcript quote library, explicitly order approved quotes, and return running timings and a formula-neutralized CSV paper edit inline. Local-only; no files, provider calls or multi-source timeline assembly.

Review caller-supplied camera/recorder offset estimates for independent-method agreement, confidence and conflicting alternatives. All matches require selection; conflicting matches cannot be approved. Does not analyze audio, calibrate confidence or synchronize Premiere.

Preview literal replacements or supplied copy changes for inspected MOGRT text and supplied caption artifacts. Preserve original text and evidence revisions with explicit approve/reject decisions. Does not translate, access native graphics/caption text or apply changes.

Remove a clip and close the gap it leaves, shifting later clips earlier on the clip's own track and on every sync-locked track so audio stays in sync. With the default scope the clip's linked audio/video partners are removed with it and their tracks close up too, even when not sync-locked; with scope 'own_track' the partners stay in place (reported as linkedPartnersKept). Premiere's QE rippleDelete() and the DOM's rippleEdit flag are both non-functional on 26.x, so this is done explicitly and verified. Refuses without changing anything if a clip on a participating track straddles the ripple point or sits inside the range being closed.

Actions or modes: scope: sync_locked, own_track; range_content: refuse, delete

Inspect or perform one guarded ripple delete on an audio or video timeline item using documented UXP SequenceEditor actions. Apply requires complete target and contiguous-successor snapshots, explicit confirmation, and an operation ID; it serializes with guarded slips, slides, and append duplicates on that track, commits one transaction, and reads back the successor at the removed coordinate. It refuses before any change when it cannot ripple: a final item, a gap, or any item on another track over the deleted range (such as a linked audio partner or a spanning layer), because Premiere then deletes without closing the gap. It does not prove media handles, linked A/V synchronization, rendered frames, playback, persistence, or Undo behavior.

Actions or modes: inspect, apply

Preview or apply a single-pass ripple removal for up to 50 sorted, non-overlapping timeline ranges on all unlocked, sync-locked tracks. Requires a preview confirmation token to apply. Integer frame rates only. The preview returns per-track counts and at most 50 planned-clip samples; clips fully inside ranges are removed. Large edits need allow_large_ripple: true.

Actions or modes: scope: sync_locked; range_content: delete

Perform a verified roll edit at the outgoing cut of a clip using the public timeline DOM, moving both visible edges and their source in/out points and verifying all four. Linked audio/video partners get the same edit by default (include_linked); every clip is checked before any is changed. Requires readable finite media and ffprobe duration evidence for every edited source; refuses unknown duration, stills, and nonunit/reversed speed before mutation.

Save the current Premiere Pro project to its existing path. Fails when the project has never been saved (use save_project_as) or when Premiere writes no non-empty file. Fresh disk metadata verifies a save; unchanged or unreadable metadata reports committed_unverified.

Save the current project to a new .prproj path. Premiere then has the NEW copy open and closes the original, so later edits go to the copy; the result reports both paths. Fails when Premiere writes no file or leaves a pre-existing path unchanged. Use open_project to return to the original.

Save the active project through UXP and require Premiere to confirm success.

Persist version1 project/sequence checkpoint references and bounded operation receipt digests in the private bridge directory. Completed/pending/unknown/failed states survive server restart. No arguments or transcripts stored; no automatic replay or project restoration.

Perform Premiere's scene edit detection on the selected clips in the active sequence (it analyses the footage and can take minutes on long clips). CreateMarkers (default) puts Segmentation markers on the selected clips' source project items (shared by every sequence that uses them), removes duplicates this run created (markers that were already there are never deleted), and reports each detected cut in source and timeline seconds; it is verified only when at least one new marker was added. ApplyCuts razors the selected clips and verifies the clip count grew. EXPERIMENTAL QE: CreateMarkers records an observed marker boundary for guarded Undo/Redo; crossing it is refused by default, and unreadable history records unknown protection. This boundary does not verify native marker reversal.

Actions or modes: CreateMarkers, ApplyCuts

Search Premiere's native transcript JSON without modifying the clip or timeline.

Search a durable Premiere project-context index for relevant sources, timeline placements, transcript passages, shots, audio observations, and notes. Returns bounded evidence with stable IDs and revisions; it never changes Premiere.

Search for project items by name, media file extension, offline status, or color label. Returns matching items with full details.

Actions or modes: item_type: clip, bin, all

Search audited built-in and explicitly supplied workspace-local workflow recipes. Recipes are declarative previews and cannot execute arbitrary tools or scripts.

Select all clips in the active sequence, or all clips on a specific track.

Actions or modes: track_type: video, audio, both

Select clips by their source project item color label. CEP exposes no timeline track-item label getter, so timeline-specific labels cannot be matched.

Select all clips in the active sequence that match a name (substring match). Optionally filter by track type and index.

Actions or modes: track_type: video, audio, both

Select every Nth clip (with an offset) among clips that match optional name, duration, time-range, track, and enabled filters, then read back the selection count. Covers 'select every other clip on V1' and similar repetitive selections without changing the timeline.

Actions or modes: track_type: video, audio, both; count_scope: per_track, across_tracks

Select all clips that overlap a time range in the active sequence.

Actions or modes: track_type: video, audio, both

Select all disabled clips in the active sequence.

Select a project item in the Project panel

Set the active sequence by name or ID

Set all tracks targeted or untargeted. Useful before insert/overwrite edits. Reads back every affected track and reports verified only when all match the requested state.

Actions or modes: track_type: video, audio, both

Set the anti-alias quality on a clip's Motion effect (useful for scaled/rotated clips).

Set a video clip's blend mode through its Opacity effect and read the stored mode back. Premiere stores the mode as an index into its modes in alphabetical order, with Subtract and Divide last (mapped on Premiere 25.2.3 by rendering every index over a known background).

Actions or modes: blend_mode: Color, Color Burn, Color Dodge, Darken, Darker Color, Difference, Dissolve, Exclusion, Hard Light, Hard Mix, Hue, Lighten, Lighter Color, Linear Burn, Linear Dodge, Linear Light, Luminosity, Multiply, Normal, Overlay, Pin Light, Saturation, Screen, Soft Light, Vivid Light, Subtract, Divide

Set the Anchor Point property on a video clip's Motion effect.

Set one timeline clip's visible duration by moving only its timeline end (TrackItem.end) while keeping its start fixed. Pass exactly one of duration_seconds or end_seconds. Works for extending still images past their import length. Refuses to overlap the next clip on the same track, rejects shortening that would strand effect keyframes unless keyframe_policy is preserve, reads start/end back, and restores the original end if Premiere clamps or ignores the write (for example when video media has no handle left). Linked audio/video partners get the same change by default (include_linked), applied as the same end offset so partners with a J/L cut keep their offset; every clip is checked before any is changed. Use this instead of speed changes, which Premiere does not expose to scripting.

Actions or modes: keyframe_policy: reject, preserve

Set the opacity of a video clip (0-100) using English or measured Spanish built-in names, then read it back.

Set and read back the pan (left/right balance) on an audio clip, including Channel Volume layouts.

Set the Position property on a video clip's Motion effect using English or measured Spanish built-in names, then read it back. Values are in pixels.

Set supported clip properties (opacity, scale, position, rotation) and read each requested value back. Clip speed is unsupported and fails before mutation; use set_clip_duration to change a clip's timeline length.

Apply Motion/Opacity values to up to 16 clips after preflighting every target property. The handler reads each requested value back and never reports a partial batch as verified.

Set the Rotation property on a video clip's Motion effect using English or measured Spanish built-in names, then read it back.

Scale a video clip evenly through its Motion effect using English or measured Spanish built-in names, and read the result back. With Uniform Scale off, both Scale (height) and Scale Width are set, so the picture is not stretched; use set_scale_width_height for different values.

Select or deselect a clip in the active sequence and read its selection state back.

Unavailable: Premiere's documented ExtendScript and UXP APIs have no setter for a timeline clip's speed (only getters), and the undocumented QE setSpeed is deliberately not used. Always fails before mutation. To change how long a clip runs on the timeline, use set_clip_duration.

Alias of set_start_time: set and verify the source project item start timecode offset.

Set an audio clip's Volume > Level in dB. Does not read or change Essential Sound Amplify automation.

Set the volume (in dB) on every audio clip of a track, or on a list of clip indices. One round trip instead of one call per clip - essential for sequences with dozens of clips.

Set the color label on a project item or clip and read it back

Set a color value on an effect property (e.g., tint color, fill color)

Set one effect property. Duplicate names require property_index from get_effect_properties. Colour values use [alpha, red, green, blue] and the lossless colour API; keyframed writes are refused. Readback reports verified, failed or committed_unverified; unreadable values are never reported as applied.

Set footage interpretation settings for a project item and read them back, including fields that were not meant to change

Request frame blending on a clip through QE DOM. Premiere exposes no frame-blend readback, so the result is committed_unverified and must be checked in Effect Controls.

Set the graphics white luminance value (HDR setting) for the project

Set in and/or out points on a project item in the project panel (marks source range for editing). Premiere snaps video marks to the media's own frame grid, so a mark is verified within one media frame and the result reports requested and applied seconds.

Set the interpolation type of an existing keyframe (Linear, Hold, or Bezier). Premiere exposes no interpolation readback, so a write is reported as committed_unverified. Stored curves do not establish rendering; verify with a short video export, or with PNG stills composited over black (they carry straight alpha).

Actions or modes: interpolation: linear, hold, bezier

Update project metadata on a project item. Supply complete metadata_xml plus updated_fields, or field_name and value to read-modify-write one XMP/project property through AdobeXMPScript with field readback. The project packet (default) stays in the project; packet 'xmp' is written by Premiere into the source media file on disk and requires the filesystem capability.

Actions or modes: packet: project, xmp

Set a project item offline, or ask Premiere to refresh it back online when offline is false.

Override the frame rate of a project item (useful for image sequences or misinterpreted media) and read it back

Override the pixel aspect ratio of a project item and read it back

Set the playhead (CTI) position, clamp it to the active sequence's end, and read the stored position back.

Unavailable: Premiere's scripting API cannot set a project item's poster frame. Fails without changing the item; set it in the Project panel (Shift+P).

Map one output audio channel of a project item to a source channel using Premiere's documented AudioChannelMapping API.

Set the project panel metadata/column configuration from XML and verify that Premiere reads back the exact XML

Set the project's scratch disks for captured video, captured audio, video previews and audio previews in one call. Each path must be an existing folder or "SameAsProject"; any rejected path fails the call.

Enable 'Scale to Frame Size' so media fills the sequence frame. Accepts a timeline clip node ID (active sequence, same IDs as get_clip_properties) or a project item node ID or name. A timeline clip is resolved first and its source project item is updated through ProjectItem.setScaleToFrameSize(). ExtendScript exposes no getter for this flag, so the result is committed_unverified unless the timeline clip's Motion > Scale reads back changed (verified). Check with get_clip_properties.

Set independent width and height scale on a clip. Turns Uniform Scale off, writes Motion > Scale Width (width) and Motion > Scale (which Premiere uses as the height once Uniform Scale is off), then reads all three back. Fails when a value does not read back.

Set one project scratch disk (captured media, previews, auto-save, CC Libraries or Motion Graphics template media) to an existing folder or "SameAsProject", using Premiere's ScratchDiskType constants.

Actions or modes: scratch_disk_type: capturedVideo, capturedAudio, videoPreview, audioPreview, autoSave, ccLibraries, motionGraphicsTemplateMedia

Change audio settings of the active sequence (sample rate, channel type).

Set the timecode display format for the active sequence and read it back. Uses Premiere's display codes (video 100-113, audio 200-201); the older 0-11 and 0-1 values are mapped onto them.

Set the field order of the active sequence.

Change the frame rate of the active sequence and verify it. Premiere re-snaps every clip to the new frame grid, so clips off that grid move by up to a frame; the result lists them (clipsMoved, movedClips) and changing back does not restore them.

Set the sequence in and out points (for an export range, etc.) and read them back. out_seconds must be after in_seconds and not past the sequence end.

Change the pixel aspect ratio of the active sequence, or return a capability error when the legacy host does not expose a writable setting.

Change the resolution (frame size) of the active sequence.

Modify and read back sequence frame-size settings.

Set in and/or out points on the clip currently open in the Source Monitor.

Set and read back the Source Monitor position using Premiere 26.3+ UXP.

Set the start time (timecode offset) for a project item

Target or untarget one video or audio track for source-patched insert/overwrite edits. Premiere allows several tracks of a type to be targeted at once, so by default (exclusive=true) targeting a track also untargets every other track of the same type. Reads back every track of that type and reports verified only when the readback matches the requested state; otherwise committed_unverified or an error.

Actions or modes: track_type: video, audio

Request time interpolation for a clip (Frame Sampling, Frame Blending, Optical Flow) through QE DOM. Premiere exposes no interpolation readback, so the result is committed_unverified and must be checked in Effect Controls.

Request enabling or disabling project transcoding on ingest. Premiere exposes no getter for independent verification, so dispatch is reported as requested_unverified.

Toggle uniform scale on a clip's Motion effect. When enabled, Scale Width and Scale Height are linked.

Set and verify the work-area points, turning the bar on first through the public Sequence API when it is off. Fails when Premiere leaves the points unchanged (26.5.2 ignores these CEP writes; use the UXP set_work_area there) and turns the bar back off if this call turned it on. Unreadable or partial writes report committed_unverified.

Switch to a specific workspace layout (e.g., 'Editing', 'Color', 'Audio', 'Effects', 'Graphics')

Merge a raw XMP XML patch into a project item's existing XMP metadata without removing unrelated fields. WARNING: Premiere writes XMP into the source media file on disk (the file's metadata block and modification time change; picture and sound are untouched). Requires the filesystem capability.

Set the starting timecode (zero point) of a sequence and read it back. The value is snapped to the sequence frame grid; for drop-frame 29.97, 01;00;00;00 is 3599.9964 s, and for non-drop 29.97 it is 3603.6 s.

Build a verified Volume > Level keyframe curve for one audio clip. Ducking-window times are relative to that clip's start; overlapping or out-of-range windows are rejected before any keyframe write.

Perform a verified slide edit on a clip using adjacent clips from the public timeline DOM. Linked audio/video partners get the same edit by default (include_linked); every clip is checked before any is changed. Requires readable finite media and ffprobe duration evidence for every edited source; refuses unknown duration, stills, and nonunit/reversed speed before mutation.

Inspect or perform one guarded slide on an audio or video timeline item using documented UXP track-item actions. Apply requires the complete three-item snapshot, explicit confirmation, and an operation ID; it serializes slides and source-only slips on the affected track, commits one transaction, and verifies every affected source and timeline boundary. Only contiguous forward 1x clips are supported. It does not prove source handles, linked A/V synchronization, rendered frames, playback, persistence, or Undo behavior.

Actions or modes: inspect, apply

Perform a verified slip edit on a clip using public source in/out properties. Requires accessible physical media duration from ffprobe; unknown duration or linked partners using different source files refuse before mutation. Linked audio/video partners get the same edit by default (include_linked); every clip is checked before any is changed.

Inspect or perform one guarded source-only slip on an audio or video timeline item. Apply requires the complete inspected snapshot, explicit confirmation, and an operation ID; it serializes slip operations per target, creates the documented source in/out actions in one undoable transaction, and reads back unchanged timeline timing plus the exact shifted source range. It supports only forward 1x clips, does not infer available media handles, and does not prove rendered frames, playback, linked-item sync, persistence, or Undo behavior.

Actions or modes: inspect, apply

Unavailable: Premiere's documented ExtendScript and UXP APIs have no setter for a timeline clip's speed (only getters), and the undocumented QE setSpeed is deliberately not used. Always fails before mutation. To change how long a clip runs on the timeline, use set_clip_duration.

EXPERIMENTAL (undocumented QE DOM): Split every clip on one track that spans a timeline time, then verify both resulting boundaries. Effect-keyframe redistribution remains unverified.

Actions or modes: track_type: video, audio

Apply Warp Stabilizer using the experimental QE DOM. Verifies component addition and readable parameter values, never analysis completion. Numeric or unreadable Method popup values remain unverified because no documented label mapping is available.

Actions or modes: method: Subspace Warp, Position, Position, Scale, Rotation

Request Adobe Media Encoder to start the render queue; reports only accepted handoff, not queue progress or output-file creation.

Start one allowlisted read-only local media analysis as a bounded cancellable process job. Native Premiere jobs are never cancelled by this tool.

Actions or modes: tool_name: inspect_media_streams, detect_audio_transients, detect_motion_peaks, read_video_scopes, analyze_video_interlacing, detect_active_picture_bounds

Request that active-sequence timeline playback stop through QE. The legacy API does not provide a same-call playhead readback, so stopped state is not reported as verified. Only the timeline can be stopped: Premiere's scripting APIs have no documented call that stops the Source Monitor alone, so target "source" returns an error instead of stopping the timeline.

Actions or modes: target: timeline, source

Set video track visibility using Premiere's track mute state (eye icon) and read the mute state back. Premiere's scripting API exposes mute, not a separate video visibility setter.

Start Adobe Speech-to-Text transcription for one exact source clip through documented Premiere 26.3+ UXP APIs. Requires exact project_item_id (or name), explicit confirmation, and operation_id. This is a guarded, privacy-aware transcript-start boundary; it does not claim transcript completion, playback, or licensed-host verification. Transcription may use Adobe cloud services per host preferences; verify data-handling policies before use.

Inspect or atomically move, trim, rename, and enable/disable one audio or video track item with stale-position guards and readback.

Actions or modes: inspect, update

Trim exactly one source in/out point and verify the corresponding visible timeline edge. Requires accessible physical media duration from ffprobe; unknown duration or linked partners using different source files refuse before mutation. Refuses retimed clips, extensions that would overlap the neighbouring clip on the same track, and, by default, trims that would leave effect keyframes outside the visible clip. Linked audio/video partners get the same trim by default (include_linked), applied as the same offset from each partner's own source point so a J/L cut or slipped audio stays in sync; every clip is checked before any is changed. To set a clip's timeline length or extend a still image, use set_clip_duration.

Actions or modes: keyframe_policy: reject, preserve

EXPERIMENTAL (undocumented QE DOM: qe.project.undo / undoStackIndex). Undo the most recent Premiere project action(s) through QE, checked step by step against Premiere's undo-stack position (stackVerified; the timeline itself is not read back). Undo history is project-wide. Only actions Premiere records are undoable: QE edits such as razor, insert, lift and extract report undoSteps (and undoStackIndex) in their results; pass that undoSteps as count to reverse exactly that call. A marker receipt with undoTracked:false recorded no undo step: calling Undo for it would reverse an earlier action. Only CEP tool results carry undoSteps; UXP tools and workflows that send several commands are not counted. Always pass expected_undo_stack_index to check the stack position, but matching position alone does not prove which action is on top. Observed marker boundaries refuse the entire request before any step unless acknowledge_untracked_markers:true explicitly permits prior non-marker actions. The barrier persists through server/helper reloads while the CEP engine remains alive; it cannot account for marker writes before observation, after an engine reset, or through UXP, the manual UI, or other clients. Matching the QE index verifies stack position only.

Unlink the currently selected video and audio clips in the active sequence, then read the links back. Premiere only unlinks when every clip of a linked group is selected, so a selection missing a linked partner is refused before anything changes.

Unnest a nested sequence clip, replacing it with the nested sequence's clips at their exact source in/out and timeline positions. Refuses without changing anything when the nest is trimmed, retimed, linked to a partner clip, contains items that also carry the other media type (Premiere's Track.overwriteClip would place that media on the matching track and overwrite the clips there), or when the destination range is occupied or locked. Re-reads every placed clip and reports failure with Undo guidance if any start or source range differs. Nested clips are re-placed from their project items, so effects, keyframes, and transitions inside the nest are not carried over.

Update the name, comments or color of the sequence marker at a time and read them back. EXPERIMENTAL (QE DOM): the receipt reports undoStackIndex movement, which does not prove QE can reverse the marker. Every marker attempt protects an engine undo boundary; undoTracked:false means the marker did not observably advance the QE index.

Validate a local CMX 3600 EDL's supported event grammar, timecodes, durations, duplicate event IDs, record overlaps, and record gaps before user-assisted Premiere interchange.

Validate that an Adobe Media Encoder .epr preset exists and ask the active Premiere sequence which output extension it produces

Validate an operator-approved local MOGRT brand kit before using it in a template or batch preview. It never reads font inventories, image pixels, or writes files.

Validate a rendered file plus title, description, hashtags, and content flags against one platform's approximate 2026 publish limits. Returns hard violations, soft warnings, normalized hashtags, and character counts. Local-only; never uploads or changes Premiere.

Actions or modes: platform: tiktok, instagram_reels, instagram_feed, instagram_story, youtube_shorts, youtube, linkedin, x, facebook_reels

Run a non-mutating export preflight for an active or named sequence. It reports blocking offline media, empty timelines, inaccessible preset/output paths, duration, and optional timeline gaps without queuing an export. readyForExport means these preflight checks passed; it does not test exporter initialization, encoder availability, or whether the host can render. Require an actual output file from export_sequence and verify_delivery_file before claiming delivery.

Read-only check that the dedicated After Effects CEP connector is running. It never reads project names, media, or paths.

Check caller-measured caption/title bounds, missing glyphs, line-break and bidirectional-text review against a rendered-artifact SHA256 and target safe zone. Pixel measurement and manual review remain explicit; this tool does not perform OCR or certify unsampled frames.

Verify a local exported file against an explicit delivery contract using ffprobe and optional EBU R128 analysis. Returns pass, fail, or not_evaluated per check; it does not prove Premiere render lineage or visual approval.

Verify that an exported delivery is a non-empty regular file and calculate a SHA-256 or SHA-512 checksum; optionally compare expected size and checksum

Actions or modes: checksum_algorithm: sha256, sha512

Verify the file:// media references of an FCPXML or FCP7 XML (xmeml) document, only inside caller-approved existing roots. References outside those roots are never statted or exposed as local paths.

Verify that a workspace-contained .mogrt artifact exists locally and has a ZIP header. This does not prove controls, import compatibility, playback, or visual correctness.

Run a safe, read-only first-run check. It proves that this MCP server, the selected Premiere bridge, an active project, and an active sequence are connected without returning project names, paths, or media details.

Actions or modes: backend: cep, uxp

Validate actual short exported video at 2–32 times with decoded RGB tolerances and optional decoded-audio RMS windows. Rejects stills and mismatched samples; records fixture/artifact hashes and explicit declared host provenance. This sampled harness does not prove all frames, Undo/reopen, playback, glyphs or destination compatibility.

Compare exact canonical snapshots for source continuity, linked identities, preserved neighbors and unexpected pieces. Reports bounded structural discrepancies. Does not certify audible A/V synchronization or rendering.

Capture a pre-dispatch readiness revision or wait, without retrying, for video-effect analysis or one documented operation-completion receipt.

Actions or modes: snapshot, analysis, operation

Wait up to 60 seconds for an exact native or local job. An uncorrelated native terminal event stops observation with requiresReconciliation, never verified completion. Optional MCP progress reports observed receipt progress. Stopping the wait never cancels accepted native work.

Actions or modes: origin: local, uxp