Docs de agentes

Video y motion · reels, timeline, tomas y clones

← Todos los módulos · Conecta tu agente →

Video y motion · reels, timeline, tomas y clones

Regla de oro: el video es código y el código es video. Todo proyecto de video se lee y se escribe como código (video_code_get / video_code_apply) y se edita con arrastrar y soltar en el editor; las dos cosas son lo mismo. Lo que hagas por código lo ve la persona en el editor y lo que ella haga en el editor lo lees como código.

Hay dos formas de hacer video en Musa:

1. Video desde un diseño (Modo Video): cada frame del diseño es una toma del reel. Se animan capas, se ponen transiciones, textos y música, y se exporta. Ideal para carruseles animados y reels de marca.

2. Proyecto de video (timeline): editor tipo CapCut con pistas de video, audio, texto, stickers y efectos. Todo el tiempo va en microsegundos (µs). Ideal para editar material grabado.

Flujos

Video como código (lo recomendado para crear y editar)

1. Crear: escribe el video como HTML + GSAP (formato HyperFrames) y llama video_project_create_from_code({ workspaceId, code, name }). También acepta Remotion (TSX/JSX) o HTML con CSS/anime.js; ese código se ejecuta en el navegador al abrir editorUrl (needsEditor: true) y queda editable.

2. Leer: video_code_get({ projectId, format: "html" | "remotion" | "json" }) devuelve el video completo: cada clip es un elemento con data-start/data-duration (textos .t, formas/imágenes/vectores .m, tomas .v1, audio <audio>) y su movimiento está en un bloque // ▸ id … // ◂ id con tl.set / tl.to / tl.fromTo.

3. Cambiar: edita ese código (texto, estilos left/top/font-size/color/background, tiempos, agrega o borra clips, reescribe los tweens de un bloque) y mándalo con video_code_apply({ projectId, code }). Lo que no toques vuelve exacto desde data-musa; en el bloque que cambies manda tu GSAP.

4. Formato mínimo de un clip nuevo: <div class="clip" data-start="1" data-duration="3"><div id="t-titulo" class="t" style="left:50%;top:40%;font-size:96px;font-weight:800;color:#fff">Hola</div></div> (posición = centro en %; media: class="m" con width:%, aspect-ratio y background, o un <svg> adentro). Movimiento: tl.fromTo("#t-titulo", { y: 120, opacity: 0 }, { y: 0, opacity: 1, duration: 0.6, ease: "power3.out" }, 1) (x/y en px desde su lugar, scale, rotation, opacity, filter blur).

5. El HTML se reproduce solo en cualquier navegador y se renderiza con HyperFrames (npx hyperframes render). La persona también puede abrir el panel «</> Código» del editor, pegar código con Ctrl+V o usar Crear › Videos › «Desde código».

3D y código vivo (Three.js, React Three Fiber, p5.js, PixiJS, WebGL, canvas, Lottie)

Lo que se dibuja en un <canvas> no se convierte en imagen fija: entra como clip de código vivo (pista M) que corre su código cuadro a cuadro y queda editable. Sirve tal cual el código que hacen las skills de video de cualquier IA (HyperFrames, Remotion, onetake).

1. Agregar a un video: video_live_add({ projectId, code, start, duration, width, params, keyframes, scene }). code puede ser HTML completo, JS suelto (import * as THREE from "three" funciona: Musa pone el import map) o Remotion TSX con <ThreeCanvas> de @remotion/three. Devuelve los parámetros que encontró.

2. Un video entero desde código 3D: video_project_create_from_code / video_code_apply con HTML que tenga un <canvas>: los textos y formas del HTML quedan como clips sueltos y el canvas como clip vivo.

3. Tiempo (cómo Musa pide cada cuadro): hf-seek con e.detail.time y waitUntil (HyperFrames), window.__seek(t) + __ready + __meta {dur,fps,w,h} (onetake), timelines GSAP en window.__timelines, useCurrentFrame() (Remotion) o un loop normal de requestAnimationFrame / renderer.setAnimationLoop / draw() de p5 (se avanza cuadro a cuadro; performance.now, Date.now y Math.random son deterministas). Lo mejor: dibujar en función del tiempo (t), no del cuadro anterior.

4. Para que sea editable sin tocar el código:

5. El código manda y se sincroniza solo (sin IA): cada cambio del inspector o de video_live_update se escribe en el código del clip al instante, y lo que se escriba en el código vuelve a ser editable.

6. En video_code_get el clip vivo es <canvas class="musa-live"> + <script type="text/musa-live"> con el código tal cual (incluido su bloque ▸ musa). El HTML exportado lo reproduce solo en el navegador y en HyperFrames; el Remotion exportado usa <MusaLive>.

7. La persona hace lo mismo en el editor: Media › «3D y código» (plantillas y «Pegar código…»); en el inspector del clip: parámetros, escena 3D (con «+ Agregar al código»), tiempo del código (inicio, velocidad, repetir) y «</> Código del clip», un panel al lado que muestra el código en vivo (se ilumina la línea que cambia) y aplica solo lo que se escribe ahí. Y directo en el lienzo: un clic sobre un objeto 3D lo elige (marco naranja con su nombre); arrastrarlo lo mueve, las esquinas lo agrandan o achican, y la barra de arriba tiene la lista de todos los objetos de la escena (también luces y fondos como un campo de estrellas, que no se eligen con un clic), cambia el color, lo duplica («Duplicar» repite sus líneas en el código, con su animación), lo quita o lo oculta. Las luces con posición se ven como puntos amarillos y se arrastran; la cámara se elige en esa lista y se mueve arrastrando el lienzo («Acercar» / «Alejar» cambian la apertura). Todo queda escrito en el código del clip. Para que la persona pueda elegir y reconocer cada objeto, dale name a cada malla (cubo.name = "Cubo" o <mesh name="Cubo">) y crea cada objeto con su propia variable (const cubo = new THREE.Mesh(...)), no dentro de un bucle anónimo.

Reel desde un diseño

1. Diseña los frames (skill musa-diseno); el orden de los frames es el orden del reel.

2. Lienzo: set_video_project({ templateId, preset: "9:16" }).

3. Animación por frame: list_animation_presets → set_animation({ templateId, frameId, presetIds }); efectos por capa con set_layer_effect o apply_expression.

4. Transiciones: list_video_effects → apply_transition. Look por toma: set_take_effects.

5. Textos y subtítulos: set_video_text. Música o voz: set_video_audio. Video o imagen encima: set_video_media. Orden y tomas: set_video_reel.

6. Exporta: video_export({ templateId }) devuelve una página que renderiza el video; ábrela.

Proyecto de timeline

1. video_project_create({ workspaceId, name, ratio, fps }).

2. video_track_add (video, audio, text, sticker, effect).

3. video_material_add (el archivo o texto) → video_segment_add({ projectId, trackId, materialId, targetStartUs, ... }).

4. Ajusta: video_segment_move, video_segment_trim, video_segment_transform, video_segment_delete, video_material_update.

5. Efectos: video_effect_apply, video_effect_update, video_effect_delete.

6. video_project_get para revisar el árbol completo; video_render({ projectId }) para renderizar.

7. Entrega el enlace: editor_open o motion_project_open.

Motion declarativo (MotionSpec)

Video hecho con código, editable capa por capa (receta probada)

Si sabes armar un video con HyperFrames, Remotion o HTML/CSS, escríbelo como manifiesto y llega a Musa como capas editables (textos en T, formas e imágenes en M, con sus keyframes). No se manda HTML ni JS: solo el manifiesto JSON.

El mismo video con las herramientas sueltas

Plantillas de video

Video con IA (llave del espacio)

Tomas (grabación con teleprompter)

Clones IA

Herramientas

Video desde un diseño

Video como código

Proyecto de timeline

Motion y 3D declarativo

IA de video

Tomas y clones

Reglas

Ejemplos

Documentación de agentes de Musaworks · actualizado 2026-11-20