Run many tool calls (any native tool: ae_*, pr_*, ps_*, ai_*, xapp_*, media_*, pixabay_*) in one go, in order — fewer round trips. steps:[{tool, input}]. stopOnError default true.

Call a catalog tool from a bundled community MCP with its arguments: {tool:"pr1__add_transition", arguments:{...}}.

Full description and input JSON schema of a catalog tool (name like "ps1__photoshop_generative_fill").

Status of the bundled community MCP libraries (installed/built, tool counts, setup notes); refresh:true reconnects and rebuilds the catalog.

Search ~550 extra tools from the bundled community Adobe MCPs (ae1/ae2 After Effects, pr1 Premiere 280 tools, ps1 Photoshop 128 tools incl. Firefly generative AI, ai1 Illustrator 66 tools). Use when no native tool fits; then adobe_catalog_describe → adobe_catalog_call.

Read or set Adobe Studio MCP settings stored on this computer: pixabayKey (Pixabay API key), mediaDir (default download folder), ytdlpArgs (extra yt-dlp args).

Talk to CEP extensions/panels LIVE inside a running app (through the Adobe Studio MCP Hub): list loaded extensions, open or close a panel by extension id, dispatch a CSEvent to extensions (many panels listen for events), listen for events and read them back, get host environment. Call a panel's ExtendScript functions with adobe_runScript.

Install an extension/plugin/script/preset from a file or folder: .zxp/.zip/folder CEP extension → user CEP folder; .ccx UXP plugin → Adobe UPIA installer; .jsx/.jsxbin → AE Scripts (or ScriptUI Panels with panel:true); .ffx → AE User Presets; .mogrt → Premiere Essential Graphics; .atn → loaded into Photoshop; .aex/.8bf/.aip/.prm → the app Plug-ins folder (admin may be needed).

Open an Adobe app by command — After Effects, Premiere Pro, Photoshop, Illustrator or Media Encoder — optionally with files (projects/images) and a specific version year; waits until it accepts scripts (wait:false to return immediately). No computer-use needed.

Discover everything installed for the Adobe apps: effect/filter plugins (.aex/.prm/.8bf/.aip), CEP extensions (panels, with bundle ids/hosts/menus), UXP plugins, ExtendScript scripts & ScriptUI panels, AE presets (.ffx), MOGRTs, Photoshop actions. Filter by app, kind, text. For live in-app effect lists also use ae_listEffects / pr_findEffects.

Open any file in the right Adobe app (.aep→AE, .prproj→Premiere, .psd/.jpg/.png/RAW→Photoshop, .ai/.svg/.eps/.pdf→Illustrator) — launches the app first if needed. app overrides the choice.

Read or edit the files of an installed extension / script / preset (manifest.xml, panel HTML/JS, host .jsx, UXP manifest.json, scripts...). Actions: list (folder), read, write (makes a .mcpbak backup first), restore (from .mcpbak). Restricted to Adobe plugin/extension/script folders.

Quit an Adobe app by command. mode: "safe" (default — refuses if anything is unsaved), "save" (saves open work first), "discard" (closes without saving), "force" (kills the process — unsaved work is lost).

Run raw ExtendScript inside an app — full scripting-DOM access to EVERYTHING the app exposes (AE app.project, Premiere app.project + QE (app.enableQE(); qe.project), Photoshop DOM + Action Manager, Illustrator DOM, BridgeTalk). The code is a function body: return a JSON-able value; helpers are preloaded (__comp, __layer, __prop, __seq, __track, __clip, __doc, __hex, __s...). ARGS holds args. Or pass file to $.evalFile a .jsx.

One-time setup / repair: installs the Adobe Studio MCP Hub CEP extension (for all 4 apps), enables unsigned CEP extensions (PlayerDebugMode), and turns on After Effects "Allow Scripts to Write Files and Access Network". Restart the apps afterwards.

Which Adobe apps are installed (versions, paths), running, and scriptable right now (transport: hub|com|afterfx|osascript), hub panel heartbeats, and next steps. Call first in a session.

Enable or disable an installed plugin / extension / script by path (renames to/from ".disabled" so the app skips it on next launch). Program Files locations may need the MCP to run as administrator.

After Effects: add an adjustment layer (optionally with effects by name/matchName) affecting everything below it.

After Effects: add a 3D camera (preset focal length mm, e.g. 35/50/85), with optional position/pointOfInterest, one-node (no POI), depth of field (focusDistance, aperture, blurLevel).

After Effects: add ANY effect (built-in or third-party plugin) by display name or matchName, optionally setting parameters {paramName: value} (colors as hex). Use ae_listEffects to discover installed effects.

After Effects: add an expression control (slider/angle/checkbox/color/point/point3d/layer/dropdown) to rig expressions against.

After Effects: add a light — point, spot, parallel, ambient — color, intensity %, position, cone angle/feather, casts shadows.

After Effects: add comp or layer markers [{time, comment?, duration?, chapter?, url?, label?}] — e.g. VO word/sync markers.

After Effects: add a mask to a layer — rect [x,y,w,h], ellipse [x,y,w,h] or path points (layer space) — with mode, feather, expansion, opacity, inverted.

After Effects: add a null object (for parenting / rigs), optionally 3D and positioned.

After Effects: add a vector shape layer — rect, roundedRect, ellipse, polygon, star or custom path (points [[x,y],...] relative to the layer center) — with hex fill/stroke. position = layer center (default comp center).

After Effects: add a solid layer (default comp size, full duration).

After Effects: per-character text animator with a range-selector reveal — typewriter, fadeInChars, scaleInChars, slideInChars, tracking — over duration seconds from startTime. basedOn chars|words|lines.

After Effects: add a text layer (point text, or paragraph text when boxSize is given) with font, size, color, stroke, tracking, leading, justification and position (default comp center).

After Effects: add a comp to the Render Queue with output path, output-module template (e.g. "H.264 - Match Render Settings - 15 Mbps", "Lossless", "High Quality with Alpha") and render-settings template; work area or custom range.

After Effects: align layers to the comp — left, hCenter, right, top, vCenter, bottom, center — with margin px (uses visual bounds, respects anchor point).

After Effects: apply a ready-made expression — wiggle, wiggleSmooth, loopCycle, loopPingpong, loopOffset, loopContinue, bounce, inertia, overshoot, time. params tune it (freq/amp/decay/rate/elasticity/gravity/bounces). bounce/inertia/overshoot ride after your keyframes.

After Effects: apply a reliable gradient (Gradient Ramp) with real colors. stops [{color:hex}, ...] (first + last used), type linear|radial, angleDeg (linear direction).

After Effects: apply an animation preset (.ffx — including third-party preset packs) to layers.

After Effects: Convert Audio to Keyframes on an audio layer (creates "Audio Amplitude" null with sliders) — for audio-reactive animation.

After Effects: animate a camera with a cinematic preset — pushIn, pullOut, truckLeft, truckRight, pedestalUp, pedestalDown, orbit — from startTime over duration, distance px, with smooth ease. Creates a camera if none.

After Effects: create a composition (defaults 1920x1080, 30 fps, 10 s) and open it in the viewer.

After Effects: delete one or more layers (undoable with Ctrl+Z).

After Effects: delete comp/layer markers — all, by index list, or within a time range.

After Effects: duplicate a layer (count copies), optionally rename and offset each copy in time.

After Effects: add properties to the Essential Graphics panel ({layer, property, name?}[]), set template name, and/or export the comp as a .mogrt for Premiere.

After Effects: run ANY menu command by name ("Create Shapes from Vector Layer", "Convert Audio to Keyframes", "Drop Shadow" layer style, "Scene Edit Detection", script/panel names under Window...) or numeric command id. Acts on the current selection — use ae_selectLayers first.

After Effects: render one frame of the comp to PNG (default current time) and return it as an image so you can check your work.

After Effects: read the active (or named) comp — size, fps, duration, current time, work area and every layer (index, name, type, enabled, in/out, parent, 3D, blend, matte). Call this first.

After Effects: list keyframes of a property — time, value, interpolation and temporal ease.

After Effects: full detail of one layer — transform values, keyframe counts, expressions, effects, masks, text.

After Effects: list comp markers (or a layer's markers).

After Effects: project overview — file path, dirty flag, bit depth, every item (comps/footage/folders with ids, sizes, durations, folder), render queue count, AE version.

After Effects: dump the property tree of a layer (or a sub-group path) — names, matchNames, values, keys, expressions — to discover exact paths for ae_setProperty / ae_setKeyframe.

After Effects: import files (footage, audio, image sequences, PSD/AI as comp or footage, .aep projects, .prproj Premiere projects) into a project folder without adding to a comp.

After Effects: import an image/video/audio/PSD/AI file into the project and (default) add it to the comp — fit contain|cover|width|height|none, position, scale, name. asGuide:true makes a locked 50% guide layer for tracing a reference. PSD/AI with asComp:true import as a layered comp.

After Effects: drive targetLayer.targetProperty from sourceLayer.sourceProperty with an expression (pick-whip), optionally from another comp, scaled by multiplier and offset.

After Effects: list every installed effect — built-in AND third-party plugins (Red Giant, Sapphire, BorisFX, Video Copilot...) — displayName, matchName, category. Filter by text/category.

After Effects: project item ops — rename, move to folder, delete, replace footage source (relink), set label, create folder, consolidate/reduce/remove unused.

After Effects: start a new empty project (refuses if the current one is unsaved unless discardChanges:true).

After Effects: open a comp in the viewer/timeline and optionally move the playhead (time) — makes it the active comp.

After Effects: open an .aep/.aepx project (current one must be saved, or pass discardChanges:true).

After Effects: parent layer(s) to a parent layer (or unparent with parent null).

After Effects: precompose layers into a new comp (moveAllAttributes default true), optionally open it.

After Effects: purge caches (all memory & disk cache / undo / image cache) to free RAM on heavy projects.

After Effects: send queued Render Queue items to Adobe Media Encoder (preferred render path), optionally adding a comp first and starting the AME queue immediately.

After Effects: Render Queue — list items/status, clear (remove all), remove index, or render now (blocking, AE internal renderer).

After Effects: move a layer to index, or to top/bottom, or above/below another layer.

After Effects: run a .jsx/.jsxbin script file (any installed script, ScriptUI panel or tool) and return its last value. Scripts in Scripts/ScriptUI Panels can be found with adobe_listPlugins.

After Effects: save the project (Ctrl+S), or Save As when path is given. backup:true also writes a timestamped copy into a "Backups" folder next to the project.

After Effects: select layers (and deselect others) — needed before menu commands that act on the selection (ae_executeCommand).

After Effects: arrange layers one after another (like Keyframe Assistant > Sequence Layers) with overlap seconds, or stagger start times by offset.

After Effects: make layers 3D (or 2D) and optionally set z position (depth) for parallax, plus material options (castsShadows, acceptsLights, acceptsShadows).

After Effects: set a layer blending mode (normal, add, screen, multiply, overlay, softLight, hardLight, colorDodge, colorBurn, difference, luminosity, color, hue, ... any AE mode name).

After Effects: change comp settings — name, width, height, duration, frameRate, pixelAspect, bgColor, work area, render 3D renderer, preserve resolution, shy/frame-blending switches.

After Effects: move the comp playhead (current time indicator).

After Effects: set (or clear with "") an expression on an effect parameter.

After Effects: keyframe one effect parameter at a time (optional ease influence %, interpolation linear|bezier|hold).

After Effects: set parameters of an effect already on a layer: properties {paramNameOrIndex: value}. With time, sets keyframes.

After Effects: set (or clear with "") an expression on any property — aliases (position, scale, rotation, opacity, anchorPoint...) or a path like "Effects>Gaussian Blur>Blurriness" / "Contents>Rectangle 1>...". Returns the expression error if any.

After Effects: set keyframe interpolation (linear|bezier|hold, in/out separately), plus roving / auto-bezier / continuous for spatial props. keyIndex, time, or all keys.

After Effects: set one keyframe on any property (aliases or path) at time with value; optional ease influence %, interpolation, easeIn/easeOut.

After Effects: directional/asymmetric temporal ease on an existing keyframe (by time, keyIndex, or all:true): influenceIn/Out 0-100, speedIn/Out.

After Effects: bulk-set many keyframes in one call (cheapest way to build motion). keys: [{layer, property, time, value, ease?, easeIn?, easeOut?, interpolation?}].

After Effects: set layer switches — enabled, audioEnabled, solo, shy, locked, guide, collapseTransformation, adjustment, effectsActive, motionBlur, frameBlending, quality (best|draft|wireframe), label (0-16), name, comment, autoOrient, timeRemap.

After Effects: toggle motion blur on layers (or all) and the comp switch; shutterAngle/phase/samples.

After Effects: set ANY property by path (any group, effect, shape content, text animator, layer style, material, camera option...) e.g. "Contents>Rectangle 1>Contents>Fill 1>Color", "Effects>CC Light Rays>Intensity", "Layer Styles>Drop Shadow>Opacity". Optional time = keyframe.

After Effects: use matteLayer as track matte for layer (alpha|alphaInverted|luma|lumaInverted|none). Image on top, shape as alpha matte = clip image into shape.

After Effects: set transform — position, scale (number or [x,y]), rotation, opacity, anchorPoint, xRotation, yRotation, orientation. With time, sets keyframes instead.

After Effects: convert an Illustrator/vector footage layer into native editable shape layers (Create Shapes from Vector Layer).

After Effects: restyle an existing text layer — font, size, color, tracking, leading, justification, caps, faux bold/italic, real text stroke (strokeColor/strokeWidth/strokeOverFill), optionally new text.

After Effects: enable time remapping on a footage/precomp layer and set remap keys [{time, sourceTime}] (freeze frames, speed ramps), or freezeAt a single time.

After Effects: time-stretch a layer (stretch % — 200 = half speed, -100 = reverse) or set playback speed %.

After Effects: set a layer inPoint/outPoint (or duration) and/or startTime (slides the layer).

Illustrator: draw rect, roundedRect, ellipse, polygon, star, line or path (points [[x,y],...]) at position [x,y] (top-left of the shape, artboard coords) with size [w,h], fill/stroke hex (or "none"), strokeWidth, opacity, name, layer.

Illustrator: add point text (or area text with box [w,h]) at position [x,y] — font (PostScript name), size, color, justification, tracking, leading, name, layer; outline:true converts to outlines.

Illustrator: apply a Live Effect via its XML definition to items/selection — e.g. , "Adobe Gaussian Blur", "Adobe Round Corners", "Adobe Offset Path", plugin effects.

Illustrator: artboards — list, add [x,y,w,h], remove index, rename, resize rect, setActive, fitToArtwork, rearrange (columns, spacing).

Illustrator: close a document (save:true saves first, else discards changes).

Illustrator: run ANY menu command by its command string on the current selection — e.g. "group", "ungroup", "outline" (create outlines), "expandStyle", "Live Pathfinder Add", "Live Pathfinder Subtract", "makeMask", "OffsetPath v22", "Make Envelope", "Expand3", "selectall", "deselectall", "fitin", "Live Blend". Third-party plugin menu items work too.

Illustrator: export artboard(s) or the document — png (scale %, transparent), jpg, svg, pdf, psd (layered, for Photoshop/AE). Returns the PNG inline when preview:true.

Illustrator: open documents and the active one — size, color mode, artboards (rects), layers (visible/locked/item counts), selection, item counts by type.

Illustrator: layer ops — list, add, rename, delete, show, hide, lock, unlock, moveToTop, moveToBottom, setActive; moveItems moves named items into the layer.

Illustrator: modify items (by name or selection) — fill, stroke, strokeWidth, opacity, moveBy [dx,dy], position [x,y], resize % [x,y], rotate deg, rename, hide/show, lock/unlock, zOrder (front|back|forward|backward), group, ungroup, delete, duplicate, blendMode.

Illustrator: new document — width/height px (pt), color mode rgb|cmyk, number of artboards, name.

Illustrator: open .ai/.pdf/.eps/.svg files.

Illustrator: place an image/PDF/PSD/SVG file at position [x,y] with optional width (keeps ratio); embed:true embeds it; trace:true runs Image Trace (preset e.g. "High Fidelity Photo", "Black and White Logo", "6 Colors") and expands to vectors.

Illustrator: play a recorded action (action + set), optionally loading an .aia action file first.

Illustrator: save in place, or save as .ai (PDF-compatible, best for After Effects import) / .pdf / .eps / .svg to path; optionally close.

Illustrator: select items — all, none, by names, by type (PathItem/TextFrame/PlacedItem/GroupItem...), by layer, or by fill color hex.

Import downloaded/local media into an Adobe app in one call: ae (project + optional add to comp), pr (bin + optional place on track at time, one after another), ps (place as smart objects in the active doc, or open), ai (place into the active doc, or open).

Inspect a YouTube (or other) URL without downloading — title, channel, duration, available resolutions/formats, chapters, subtitles, playlist entries.

Manage the media helper tools: status (yt-dlp/ffmpeg paths & versions), install, update (yt-dlp -U — fixes most YouTube errors), or convert a local file with ffmpeg (to mp4 H.264 / mov ProRes / mp3 / wav / gif / extract audio).

Download video or audio from YouTube (videos, Shorts, playlists) — and 1000+ other sites — with yt-dlp. Formats: mp4 (default, edit-friendly H.264+AAC for AE/Premiere), mov, mkv, webm, mp3, wav, m4a, aac, flac, opus, ogg. quality: best|2160|1440|1080|720|480|360. Clip only a section with start/end. Subtitles (.srt), thumbnail, playlist. Optionally import straight into an Adobe app. Only download content you own or have permission/licence to use.

Download Pixabay assets by id (from pixabay_search) to disk — images at the best size your key allows (large 1280px, or full-res / vector SVG/AI with full API access), videos at large (4K/1080p) | medium | small | tiny — then optionally import them into AE / Premiere / Photoshop / Illustrator.

Search Pixabay (free licence stock) through the official developer API — photos, illustrations, vectors, videos (film/animation). Filters: orientation, category, colors, min size, editors choice, order popular|latest, safesearch, page/perPage, lang. Returns ids, tags, sizes, previews. (The public API has no music or sound effects.)

Premiere Pro: add text captions/subtitles from cues [{start, end, text}] (seconds) — builds an .srt and creates a caption track on the sequence. Reliable editable on-screen text.

Premiere Pro: place a Motion Graphics template — built-in by name (e.g. "Basic Title", "Basic Lower Third") or a .mogrt path (also AE-exported) — on a video track at time; set its text (or texts {paramName: text}) and duration. Returns editable parameter names.

Premiere Pro: add sequence markers [{time, name?, comment?, duration?, color 0-7?, type comment|chapter|segmentation|weblink, url?}] — e.g. review points before cuts.

Premiere Pro: run many pr_* steps in ONE call, in order: steps:[{tool:"pr_addMarkers", input:{...}}, ...]. Stops at the first error unless stopOnError:false. (Works for any native tool, so ae_/ps_/ai_/xapp_ steps can be mixed in.)

Premiere Pro: apply a video or audio effect (built-in or plugin, by exact name from pr_findEffects) to clips, optionally setting its parameters {paramName: value}.

Premiere Pro: add a transition (video: "Cross Dissolve", "Dip to Black", "Film Dissolve"...; audio: "Constant Power"...) at the start, end or both of clips, duration seconds.

Premiere Pro: clip operations — select/deselect, link/unlink (selection), rename, set color label, replace footage (changeMediaPath on the project item), set name of item.

Premiere Pro: create a bin (nested paths like "Footage/Day 1" supported).

Premiere Pro: create a sequence — from clips (settings match the first clip), from a .sqpreset, or a default preset then width/height/fps applied (e.g. 3840x2160 @ 25).

Premiere Pro: delete sequence markers — all, by name, or in a time range.

Premiere Pro: duplicate a sequence (safe copy before big/destructive edits) and optionally rename the copy / open it.

Premiere Pro: export a sequence with an .epr preset — via Adobe Media Encoder queue (default, starts batch) or directly inside Premiere (direct:true, blocking). range entire|inToOut|workArea. Default preset: "Match Source - Adaptive High Bitrate".

Premiere Pro: export the frame at a time (default playhead) as PNG and return it as an image to check the edit.

Premiere Pro: export the sequence as Final Cut Pro XML (interchange with AE/DaVinci/others), as an AAF, or as a standalone trimmed .prproj (exportAsProject).

Premiere Pro: search installed video/audio effects and transitions — built-in AND third-party plugins — by name.

Premiere Pro: every effect component on a clip with its parameters, values and keyframes (Motion, Opacity, Volume, Lumetri, plugins...).

Premiere Pro: project name/path, sequences (name, id, active) and every project item (bins, clips, sequences, media paths). Call before referencing items.

Premiere Pro: clips currently selected in the timeline (track + 1-based index usable as clip refs).

Premiere Pro: active (or named) sequence — frame size, fps, duration, playhead, in/out, every video/audio track (mute/lock) with its clips (1-based index, name, start/end, source in/out, enabled, speed, media path) and markers. Clip numbers change after edits: re-read.

Premiere Pro: import an .srt (or other caption file) onto a new caption track starting at time (default 0).

Premiere Pro: import media files (video, audio, images, PSD, AI, .aep comps, .mogrt, .srt) into a bin (created if missing). numberedStills imports an image sequence.

Premiere Pro: move a clip in time (toTime or by offset seconds) and/or to another track of the same type (toTrack, re-placed with the same source in/out).

Premiere Pro: move project items (names/paths) into a bin; also rename or set a color label.

Premiere Pro: create a new project at path (.prproj) and make it current (save the open project first).

Premiere Pro: open a sequence in the timeline and make it active.

Premiere Pro: place a project item (name/path/media path — or a file path, imported automatically) on a track at a time — overwrite (default) or insert (ripples) — optionally trimmed to source inPoint/outPoint seconds.

Premiere Pro: razor (cut) at one or more times across all tracks or the listed tracks.

Premiere Pro: remove clips from the timeline (media stays in the project). ripple:true closes the gap.

Premiere Pro: cut a time range out of the timeline (razor at start & end, remove what is inside) on all or listed tracks; ripple (default true) shifts later clips left to close the gap. Duplicate the sequence first for safety.

Premiere Pro: save the project (or Save As path); backup:true also writes a timestamped copy into a "Backups" folder next to it.

Premiere Pro: sequence-level AI/automation — autoReframe (new aspect sequence, e.g. 9:16 for Shorts), sceneEditDetection (markers or cuts on selected clips), createSubsequence (from in/out), rename, close.

Premiere Pro: enable/disable clips (disabled clips stay on the timeline but do not render).

Premiere Pro: set Motion/Opacity on video clips (scale %, position [x,y] px 0,0 top-left, rotation deg, anchorPoint px, opacity 0-100) or volume dB on audio clips. keyframes:[{time (timeline s), scale?, position?, rotation?, opacity?, volume?, interpolation?}] are ADDED. A static value on a keyframed parameter is refused unless replaceKeyframes:true.

Premiere Pro: change clip speed (percent, 200 = 2x), reverse, maintain audio pitch, ripple.

Premiere Pro: set parameters of any effect component on a clip (by component displayName, e.g. "Lumetri Color", "Gaussian Blur", "Motion") — static values or keyframes [{time, value}] (timeline s). Colors as hex.

Premiere Pro: set (or clear) sequence in/out points — or a project item's source in/out with item.

Premiere Pro: move the timeline playhead to a time.

Premiere Pro: track operations — add video/audio tracks, mute/unmute, lock/unlock, target/untarget tracks (for inserts/pastes).

Premiere Pro: trim a timeline clip — new timeline start/end (seconds) and/or source inPoint/outPoint.

Photoshop: run ANY Photoshop command (full feature access incl. every filter, neural/AI command, third-party plugin filter, menu item) with batchPlay-style JSON: commands:[{"_obj":"gaussianBlur","radius":{"_unit":"pixelsUnit","_value":4}}, {"_obj":"set","_target":[{"_ref":"layer","_enum":"ordinal","_value":"targetEnum"}],"to":{"_obj":"layer","opacity":{"_unit":"percentUnit","_value":50}}}]. IDs are stringIDs; prefix "$" for a charID ("$Lyr "). Returns result descriptors. dialogs:true shows the plugin dialog.

Photoshop: add a text layer — text, font (PostScript name), size pt, color, position [x,y] px, justification, paragraph box [w,h], tracking, leading, allCaps, fauxBold.

Photoshop: add an adjustment layer — brightnessContrast {brightness, contrast}, hueSaturation {hue, saturation, lightness, colorize}, vibrance {vibrance, saturation}, exposure {exposure, offset, gamma}, levels, curves, colorBalance, blackAndWhite, photoFilter, channelMixer, invert, posterize {levels}, threshold {level}, gradientMap, selectiveColor. clip:true clips it to the layer below.

Photoshop: apply a filter to a layer (converts smart objects? no — on smart objects use ps_actionManager for smart filters) — gaussianBlur {radius}, motionBlur {angle, distance}, unsharpMask {amount, radius, threshold}, addNoise {amount, mono}, highPass {radius}, median {radius}, dustAndScratches {radius, threshold}, clouds, lensFlare? (use ps_actionManager for any other / third-party filter).

Photoshop: close a document — save:true saves first, otherwise changes are discarded.

Photoshop: content-aware fill the current selection (or rect [x,y,w,h]) on the active/named layer — removes objects.

Photoshop: export each top-level layer (or the listed ones) as its own PNG (trimmed or full canvas) into a folder — e.g. cut-outs for After Effects parallax.

Photoshop: read Action Manager properties (application, document, layer, channel...) as JSON — e.g. target [{"_ref":"layer","_enum":"ordinal","_value":"targetEnum"}], optional property "layerEffects". Discover what ps_actionManager can set.

Photoshop: open documents and the active document — size, resolution, mode, bit depth, path, saved flag, full layer tree (type/kind, visibility, opacity, blend, bounds, text), active layer.

Photoshop: layer operations — select, rename, show, hide, opacity, fillOpacity, blend, delete, duplicate, moveTop, moveBottom, moveUp, moveDown, lock, unlock, rasterize, mergeDown, translate [dx,dy], resize % [x,y], rotate deg, newLayer, newGroup, groupLayers (names), fillColor.

Photoshop: add layer effects — stroke {size, color, position outside|inside|center, opacity}, dropShadow {distance, size, angle, opacity, color, spread}, outerGlow {size, opacity, color, spread}. clear:true removes all effects.

Photoshop: create a new document (px) — width, height, resolution, name, mode rgb|cmyk|gray|lab, fill white|black|transparent|background, bits 8|16|32.

Photoshop: open image/PSD/PDF/RAW files (asSmartObject opens as smart object).

Photoshop: place a file (image, PSD, AI, PDF, video) as an embedded or linked smart object, optionally scaled % and moved so its center is at position [x,y].

Photoshop: render the current document (merged, downscaled to maxSize px) and return it as an image to check your work.

Photoshop: AI Remove Background on a layer (adds a layer mask around the subject; smart objects/backgrounds are converted as needed).

Photoshop: image size (width/height px, resample), canvas size (anchor), crop [left,top,right,bottom], rotate canvas deg, trim transparent pixels, flatten, flip horizontal/vertical.

Photoshop: play a recorded action from the Actions panel (action name + set name) — including third-party action packs. loadAtn loads an .atn file first.

Photoshop: run a menu item by its stringID (e.g. "flattenImage", "newPlacedLayer", "copyMerged", "selectAllLayers", "toggleRulers") via app.runMenuItem.

Photoshop: save the document — in place (Ctrl+S) or as psd|psb|png|jpg|tif|pdf|webp to path (asCopy default true for non-PSD), jpg quality 0-12, then optionally close.

Photoshop: selections — all, none, invert, rect [x,y,w,h], ellipse [x,y,w,h], subject (AI Select Subject), sky, layerTransparency, feather {value}, expand {value}, contract {value}, smooth {value}; then optional fill hex, delete, or mask (adds a layer mask from the selection).

Photoshop: smart objects — convert layer to smart object, edit contents (opens it), replace contents with a file, export contents to a file, rasterize.

Dynamic Link: bring After Effects comps into Premiere Pro WITHOUT rendering (live-linked; edits in AE update in Premiere). Uses the saved .aep (saves the open AE project first if aepPath omitted). Optionally places the first comp on a track at time.

BridgeTalk: from one running Adobe app, send ExtendScript to another (targets: aftereffects, premierepro, photoshop, illustrator, ame, bridge, indesign... optionally versioned "photoshop-27.0") and wait for its result — Adobe's native inter-app messaging. Useful when the target has no direct connection.

Grab a frame from After Effects (comp) or Premiere (sequence) at a time and open it in Photoshop (new document or as a layer in the active one) — thumbnails, retouching, matte painting.

Illustrator → After Effects: save the active AI document (PDF-compatible), import it into AE as a layered comp, and (shapes:true, default) convert every vector layer to native editable AE shape layers.

After Effects → Premiere via Motion Graphics template: publish chosen AE properties to Essential Graphics, export the comp as .mogrt, and place it in Premiere with text overrides — editable titles/lower-thirds in the edit.

Photoshop → After Effects: save the active (or named) PSD, import it into AE as a layered composition (each PS layer = AE layer, layer styles editable), optionally adding it into a target comp — ideal for parallax / paper-cut animations.

Send a Premiere Pro sequence to After Effects: saves the Premiere project (or exports a trimmed project with just that sequence), then imports it into AE — sequences become AE comps with the clips as layers (like "Replace with After Effects Composition", but scriptable).

Look at what any app currently shows: AE comp frame, Premiere frame at playhead, Photoshop document, or Illustrator artboard — returned as an image for a quick visual self-check.

Render an After Effects comp to a file (AE render queue, blocking; e.g. ProRes 4444 / "High Quality with Alpha" / H.264) and import + place the result in Premiere — when Dynamic Link playback is too heavy.

Photoshop / Illustrator → Premiere Pro: save the active PS document (PSD or PNG) or export the active AI artboard (PNG), import into a Premiere bin and optionally place on a track at time with a duration.