i'm jon, i co-founded 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.
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-up. 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
video docs: docs.backboard.io/sdk/video-tool