# Make a Runway Clone in one shot, or something else!

> Source: <https://dev.to/jon_at_backboardio/make-a-runway-clone-in-one-shot-or-something-else-5hdg>
> Published: 2026-09-17 17:20:20+00:00

*i'm jon, i co-founded [backboard.io](https://backboard.io). this is a launch post. it's short and there's code.*

video models are live on backboard.

Here is a video of me and my dog rapping if you don't believe me.

ByteDance's Seedance family is in, served through OpenRouter, along with the rest of the OpenRouter video catalog.

that's the news. here's why you should care.

text you've figured out. images, mostly. video is where it gets ugly.

every provider has its own job api. submit. get an id. poll. poll again. time out. retry. download the file. store it somewhere. pass a url back to your agent. hope the agent remembers what it made two turns ago.

that's a whole service. for one feature. and it's different for every model.

so we built it once. same way we did memory, rag, routing, voice and image.

**ByteDance Seedance**

`bytedance/seedance-2.5` (up to 30s, with audio)`bytedance/seedance-2.0`` bytedance/seedance-2.0-fast`
`bytedance/seedance-2.0-mini`

**the rest of the OpenRouter video catalog**

Veo 3.1, Wan 3.0, Kling 3.0, Hailuo 3, Grok Imagine and more

`client.list_video_models()` shows exactly what's live and what each model supports. `client.get_video_model(model_id)` gives you one model's limits.

six ways in:

text to video

first frame to video (animate an image)

first and last frame

video to video (edit, extend, upscale)

references (images, audio or video as a guide)

mixed references

it's the `add_message` call you already make. four extra keys.

``` python
import asyncio
import os
from backboard import BackboardClient

settings = {
    "llm_provider": "openai",
    "model_name": "gpt-4.1",
    "video_generation": "auto",
    "video_model_provider": "openrouter",
    "video_model_name": "bytedance/seedance-2.0-fast",
    "video_config": {"duration": 5, "aspect_ratio": "16:9", "resolution": "720p"},
}

async def main():
    client = BackboardClient(api_key=os.environ["BACKBOARD_API_KEY"], timeout=1900)
    assistant = await client.create_assistant(name="video assistant")
    thread = await client.create_thread(assistant.assistant_id)
    thread_id = str(thread.thread_id)

    result = await client.add_message(
        thread_id,
        content="a paper boat drifting down a rainy city gutter, golden hour",
        stream=False,
        **settings,
    )

    for message in result.messages:
        for media in message.get("generated_media") or []:
            print(media["document_id"], media["url"])

asyncio.run(main())
```

no job queue. no polling loop. we poll for you, for up to 30 minutes, and hand back the clip.

every clip comes back in `generated_media` with a `document_id` and a url. it lives in the thread. next to the memory. next to everything else your agent already knows.

want to animate an image instead? add a file.

```
result = await client.add_message(
    thread_id,
    content="slow push in, steam rising off the coffee",
    files=["start.png"],
    stream=False,
    **settings,
)
```

two files is first frame plus last frame. an `.mp4` is video to video.

the clip isn't a loose file. it's in the conversation. so the next turn can just be:

```
await client.add_message(
    thread_id,
    content="same shot, but at night. neon reflections in the water.",
    stream=False,
    **settings,
)
```

no re-uploading. no passing urls around. the agent knows what it made, because it made it in the same thread.

`video_generation="auto"` hands your assistant a `generate_video` tool. it calls it when the ask needs a video. it won't render one because you said hi.`stream=True` and a long client timeout. we use 1900 seconds.`video_config` covers duration, resolution, aspect ratio, size, audio, seed, upscale and provider routing. only where the model supports it. check `get_video_model()` first.`operation="generate_video"`. swap `bytedance/seedance-2.0-fast` for `google/veo-3.1-fast`. one string. nothing else moves.

that's the whole backboard thing. the model is a parameter. text, voice, image and now video, behind one key, with memory under all of it. so your agent doesn't forget what it just made.

you were going to write that polling loop this weekend. don't.

get a key: [app.backboard.io](https://app.backboard.io)

video docs: [docs.backboard.io/sdk/video-tool](https://docs.backboard.io/sdk/video-tool)