MediaKit is a professional toolkit for audio, video, and image processing. It unifies common media processing, content understanding, and
intelligent enhancement capabilities into mediakit-cli, suitable for the complete workflow from material processing to final production.
Usage Rules
- Through this Skill or a domain Skill actual execution
mediakit-cliFor business commands, the source and host must be injected in the same call to prevent the CLI from being unable to identify the call source:MEDIAKIT_SURFACE=skill(This Skill / domain Skill calls are fixed toskill)MEDIAKIT_RUNTIME=<当前 Agent 宿主>(when it cannot be determined, useunknown)
- Injection method: set environment variables before the command (recommended); do not treat these two values as CLI flags or business parameters.
--help/--schema/--domains/--versionRead-only discovery commands such as these may skip injection; once a real processing orshared query-taskis initiated, injection is required.
Example (include it in every real call):
MEDIAKIT_SURFACE=skill MEDIAKIT_RUNTIME=<runtime> mediakit-cli editing add-image-to-video --video-url <url> --sub-image-url <url>
MEDIAKIT_SURFACE=skill MEDIAKIT_RUNTIME=<runtime> mediakit-cli shared query-task --task-id <task_id>
<runtime> Fill in the current host identifier (such as cursor、claude-code、codex); when uncertain, fill in
unknown. Do not omit MEDIAKIT_SURFACE=skill。
Capability Scope
- Video Editing and Compositing: cropping, concatenation, transitions, speed adjustment, volume adjustment, video filters, camera movement, image overlay, subtitle burning, mixing, fade in/out, audio/video extraction and merging, text scrolling, image-to-video, and multi-screen arrangement.
- Audio and Audio Track Processing: audio transcoding and media asset detection, speech boundary localization, vocal and background sound separation, and processing for video audio tracks.
- Video Understanding and Enhancement: video content analysis, plot/script and highlight segment splitting, image quality enhancement and image quality detection, frame extraction, speech-to-subtitle and subtitle extraction, subtitle erasure, watermark processing, privacy protection, scene and semantic segmentation, on-screen text recognition, transcoding and remuxing, keying and face swapping, etc.
- Image Processing and Content Understanding: size scaling and volume governance, metadata detection, cropping, rotation, flipping and rounded corners, color and sharpening, negative, blur and mosaicking, watermarking, background removal, text recognition, image quality assessment and intelligent cropping, etc.
Capability Selection and Priority Loading
Select a domain Skill according to the user's processing object and explicit goal:
| User Goal | Priority Loading |
|---|---|
| Crop, concatenate, transition, filter, camera move, overlay, mix, or final production arrangement on existing materials | byted-mediakit-editing |
| Process audio transcoding, audio tracks, speech boundaries, or vocals and background sound | byted-mediakit-audio |
| Process single or batch images, size and volume governance, text recognition, image quality, or image editing | byted-mediakit-image |
| Video understanding, highlight segment splitting, frame extraction, image quality enhancement or detection, subtitle extraction, speech-to-subtitle, subtitle erasure, watermark, privacy, transcoding, or intelligent video processing | byted-mediakit-video |
If a single request contains multiple stages, first load the domain Skill that best matches the primary output, then load other domain Skills as required by the workflow. If the request only says "process a video" or "process an image" without stating a goal, first clarify with the user; do not guess specific capabilities based on the media type.
After selecting a domain, you must first read that domain Skill, then read the complete reference of the finally selected tool, and finally construct parameters according to the machine contract of the current CLI. The shared entry point is only responsible for capability navigation and general CLI usage; it does not repeat specific tools' parameters, enums, or result fields.
Installation and availability check
On first use, install the CLI and the accompanying Skills:
npx @volcengine/mediakit-cli install -y
After installation, verify the public entry point:
mediakit-cli --version
mediakit-cli --help
To reinstall the Skills bundled with the current version, run:
npx @volcengine/mediakit-cli install --skills-only -y
Initialization and check
mediakit-cli init
mediakit-cli config show
mediakit-cli doctor
doctor Used to check the current CLI and local processing dependencies; whether a specific tool supports local processing is subject to the corresponding domain Skill and tool reference.
Command discovery and machine contract
mediakit-cli --domains
mediakit-cli <domain> --help
mediakit-cli <domain> <tool> --help
mediakit-cli <domain> <tool> --schema
--schema Only read the machine contract of the current effective mode; do not initiate business calls; the top level contains name、
description、input_schema and output_schema. Before constructing parameters, first read the target tool's
--help and --schema, and use the field descriptions in the complete reference as Agent usage guidance.
Media input
Pass the user-provided media input directly to the tool parameters. For local files, pass the local file path (such as
/path/to/file.jpg or ./file.jpg); do not add the mediakit:// prefix yourself; the CLI's media input adapter will handle the upload. There is no need to create additional upload commands or upload parameters.
Cloud / Local mode
When no mode is specified, the CLI's current configuration chooses Cloud-first or Local-first.--local and
--cloud are only used for a single command override; the CLI's --help and --schema only show the parameters and results of the selected mode.
The canonical command order is:
mediakit-cli --cloud <domain> <tool> [flags]
mediakit-cli --local <domain> <tool> [flags]
Parameters unsupported by Local must not be silently ignored; switch to Cloud or remove the corresponding parameters. Local tools return processing results synchronously and do not produce Cloud asynchronous tasks. The Local output directory is managed through CLI configuration:
mediakit-cli config set output-path <输出目录>
Asynchronous results
Cloud asynchronous capabilities return task_id. First use the shared query command to obtain the task status and final business result:
mediakit-cli shared query-task --task-id <task_id>
If you need to keep waiting for a terminal state, follow the query protocol in query_task.md .
Update
mediakit-cli update
mediakit-cli update --check
mediakit-cli version --check
Shared query protocol
| Protocol | Description | Command | Reference |
|---|---|---|---|
| query-task | Query Cloud asynchronous task status and terminal business result. | mediakit-cli shared query-task |
reference/query_task.md |