---
name: vixdeo
description: Produce a finished video with Vixdeo through its MCP server: quote first ($0), create the piece from an idea, a script or declared sources, follow production to the final video, edit scenes with the Studio's operations, and bring the user's own material (clips, photos, their voice) into the piece. Use when the user asks to make, quote, edit or follow a video with Vixdeo, or to add their own footage to one.
license: Proprietary — see https://vixdeo.com/legal/terms
metadata:
  version: "rc.630"
  homepage: "https://vixdeo.com"
  mcp: "https://vixdeo.com/v1/mcp"
  readme: "https://vixdeo.com/docs/mcp/README.md"
  tools: "https://vixdeo.com/v1/mcp/tools"
---

# Vixdeo — produce a finished video from an idea, a script or your own material

Vixdeo is an AI editorial video production platform; it is not ViX (TelevisaUnivision's streaming service) nor Videx. Vixdeo is the AI video producer: it turns an idea or a script into a finished piece - fact-checked script, voice, music and visuals directed scene by scene - operable by people and by agents.

This skill teaches you to drive Vixdeo through its MCP server. Everything below is derived from the live
contract: when in doubt, read `https://vixdeo.com/v1/mcp/tools` (the same catalogue `tools/list` returns, with input
schemas) and `https://vixdeo.com/docs/mcp/README.md`.

## Connect first

The server is `https://vixdeo.com/v1/mcp` (MCP Streamable HTTP, JSON-RPC 2.0, protocol 2025-06-18).
Two ways in:

- **API key** (programmatic agents): the user creates one at `https://vixdeo.com/settings` (Access for agents) and you send
  `Authorization: Bearer vbp_live_…`. Claude Code: `claude mcp add --transport http vixdeo https://vixdeo.com/v1/mcp --header "Authorization: Bearer <key>"`.
  Codex: `codex mcp add vixdeo --url https://vixdeo.com/v1/mcp`.
- **OAuth 2.1** (hosts with a consent screen): add `https://vixdeo.com/v1/mcp` as a remote MCP server; the host registers
  itself (CIMD or RFC 7591), PKCE S256, scopes `read` `write`.

Without credentials the server answers 401 with `WWW-Authenticate: resource_metadata=…`. There is a single
MCP endpoint, `/v1/mcp`; there is no SSE transport.

## The canonical flow

1. `whoami` — who you are, scopes, wallet and whether you operate the platform
2. `list_referents` — the formats, the duration and writing profiles, the defaults
3. `estimate` — the price band and whether the request is complete, BEFORE spending ($0)
4. `generate_script` — creates the piece; with auto_produce=true the line runs on its own to the video
5. `get_project_status` — the status; polled every 60-120 s because the server never pushes

To edit before producing: `generate_script` with `production.auto_produce=false`, then `get_project_vbp`,
then `stage_op` / `run_op` (deterministic edits) or `direct` (LLM re-authoring), then `commit`, then `produce`.
`list_versions` / `set_head` navigate the cut.

## Rules you must keep

- **Quote before you spend.** `estimate` costs $0 and says whether the request is complete and what the price
  band is. Tell the user the band before launching.
- **Nothing is pushed to you.** Poll `get_project_status` every 60–120 s; a piece usually takes 20–60 min. Do
  not tell the user the video is ready until the status says so.
- **Never infer a voice or a presenter.** Name one from `list_cast` (`id` is the key, `@handle` the label) or
  describe one with `cast.describe_face`; otherwise the house resolves it from the catalogue.
- **Publishing is a human decision in the app.** No tool publishes to a channel.
- **Who pays.** Charged to your organization’s wallet: `author_op`, `direct`, `generate_script`, `rewrite_script`, `produce`, `regenerate_from_source`. `judge_script`, `derive_rendition` call a provider that Vixdeo pays: they do not touch your wallet. `stage_op` ($0): `assign_material_to_shot`, `assign_narration_to_scene`, `remove_narration_from_scene`, `replan_scenes`, `set_piece_fields`, `set_scene_fields`, `set_visual`, `swap_voice`. `author_op` (charged to the wallet, in the turn): `revestir_como_autor`, `rewrite_scene`, `tighten_hook`. `run_op` is a deprecated alias of `stage_op` + `author_op` and charges only on the paid ops.
- **Write tools may require the user's approval on every call.** That is the host's policy, not a server error.
- **Say what the house declares.** `get_project_status.fidelityReport` is derived without a model from what the
  pipeline wrote on the cut; relay it, do not embellish it.

## Tools (28; 10 read-only)

- `list_ops` (List edit ops) — read-only; cost: $0
- `list_referents` (List formats) — read-only; cost: $0
- `estimate` (Estimate cost) — read-only; cost: $0
- `list_cast` (List voices and presenters) — read-only; cost: $0
- `list_projects` (List projects) — read-only; cost: $0
- `get_project_vbp` (Read Video Blueprint) — read-only; cost: $0
- `stage_op` (Stage a free edit op) — write; cost: $0
- `author_op` (Re-author with the LLM (paid)) — write, destructive; cost: charged to the wallet, in the turn
- `run_op` (Run an edit op (deprecated)) — write, destructive; cost: charged to the wallet only for `revestir_como_autor`, `rewrite_scene`, `tighten_hook`; the other ops are $0 (deprecated alias of `stage_op` + `author_op`)
- `direct` (Direct the piece) — write, destructive; cost: charged to the wallet, in the turn
- `commit` (Commit a version) — write; cost: $0
- `generate_script` (Create a project) — write, destructive; cost: charged to the wallet, at settlement
- `get_project_status` (Get project status) — read-only; cost: $0
- `judge_script` (Judge the script) — write; cost: $0 to the wallet: Vixdeo pays the provider
- `rewrite_script` (Rewrite the script) — write, destructive; cost: charged to the wallet, at settlement
- `derive_rendition` (Derive a rendition in another language) — write; cost: $0 to the wallet: Vixdeo pays the provider
- `produce` (Produce the video) — write, destructive; cost: charged to the wallet, at settlement
- `cancel` (Stop the production line) — write, destructive; cost: $0
- `list_versions` (List versions) — read-only; cost: $0
- `set_head` (Make a version the cut) — write; cost: $0
- `update_gallery_work` (Update the gallery work) — write; cost: $0
- `regenerate_from_source` (Regenerate from the changed source) — write, destructive; cost: charged to the wallet, at settlement
- `whoami` (Who am I) — read-only; cost: $0
- `request_upload` (Request upload ticket) — write; cost: $0
- `complete_upload` (Register uploaded material) — write; cost: $0
- `list_material` (List own material) — read-only; cost: $0
- `assign_material` (Assign material to a scene) — write, destructive; cost: $0
- `assign_narration` (Set a recording as a scene's narration) — write, destructive; cost: $0

Own material (photos, video, recorded audio): `request_upload` with the exact `size_bytes` (one file, or up to 20 in `files`: one ticket per file, and a file that is refused does not stop the others) → PUT the bytes straight to storage → `complete_upload` (say what each file shows; several at once in `uploads`) → `assign_material` (an image or a video becomes the visual of a scene; audio files are kept in the library and cannot be placed on a scene yet) → `produce`. A large file travels in parts: with `resumable=true` each part has its own signed URL and, after an interruption, `request_upload` with only the `handle` returns the parts that arrived and signs the missing ones. Each ticket states the limit per file in force (`maxBytes`) and the space in use (`quota`); a refusal says which limit was reached. Every file is verified before it can be used — it has to be real media of the declared size, and its content identifies it, so the same file uploaded twice is one asset — and its `stage` says where it is: `uploading`, `verifying`, `ready`, or `failed` with a `reason`. Small files are `ready` in the same answer; `list_material` shows the others while they are verified. `generate_script` and `estimate` take `material` (the `assetId`s of files that are `ready`): the files are stored with the piece and stay at hand to be placed on its scenes; the script is not written around them yet. It depends on the account: the `direction` in the answer of `estimate` and `generate_script` says yours. On a piece whose final is already delivered, `produce` answers with the quote of a new final render (`finalRender`) and launches it only with `confirm_spend=true`. After a file is verified it can carry a `ficha`: what the system saw and heard in it (measures, a description of the frames, what is said, faces), with its own `stage` — `reading` while it is being written, then `ready`, or `failed` with a `motivo`; the file does not wait for it. `list_material` takes `origin`: `own` (the default) is what the creator uploaded; `declared_source` are the figures the system took from the sources the creator declared for a piece, each with its `provenance` (credit, license and a `stance`: `mountable`, `forbidden`, `permission_pending`, `citation`); `all` lists both.

## Example prompts

**Quote without launching anything ($0)** (tools: whoami · list_referents · estimate)

> Using Vixdeo: tell me who I am and my wallet balance, list the available formats and quote a 3-minute educational explainer in Spanish about “how an mRNA vaccine works”. Do not launch anything: I want the price band, whether the request is complete, and at which station the line would stop if the wallet did not cover it.

**Launch the script without producing, then edit a scene** (tools: list_cast · generate_script (auto_produce=false) · get_project_status · get_project_vbp · stage_op · commit)

> Using Vixdeo: find a male Spanish voice in list_cast and use its id. Create a short critical essay in Spanish about “silence in Bresson’s cinema” with production.auto_produce=false and that voice in cast.voice. When the script is ready (check the status every minute), read the blueprint, halve the narration of scene 0 with stage_op set_scene_fields, commit, and tell me the id and sequence of the new version. Do not produce the video.

**Review versions, move the cut and report publication** (tools: list_projects · list_versions · set_head · get_project_status)

> Using Vixdeo: find my most recent project in FINAL_REVIEW or STUDIO_READY, list its versions with sequence, origin and isHead, and if an earlier version has the same number of scenes make it the cut with set_head. Then report the publication state (publication) and the final video URL if it exists. Publishing to a channel is not available from the connector: it is a human decision in the app.

## Live references

- Connector README (tools, costs, limits): `https://vixdeo.com/docs/mcp/README.md`
- Tool catalogue with annotations and schemas, no credential: `https://vixdeo.com/v1/mcp/tools`
- llms.txt: `https://vixdeo.com/llms.txt` · REST quickstart: `https://vixdeo.com/v1/quickstart.md` · errors (RFC 7807): `https://vixdeo.com/errors`
- Privacy: `https://vixdeo.com/legal/privacy` · Terms: `https://vixdeo.com/legal/terms` · third parties: `https://vixdeo.com/legal/subprocessors`
- Support: support@vixdeo.com