Introducing Agentic Video Creation

AI agents can draft a contract, book a flight, refactor a codebase, and manage a marketing calendar. They are fluent in text, competent in code, and increasingly capable of multi-step reasoning across complex domains.

They cannot make a video.

Not because the task is conceptually difficult — agents are already writing the copy, choosing the audience, and scheduling the distribution. The problem is the last mile. Between "we should announce this product" and a finished 30-second motion graphics asset, there is a gap that no amount of language modeling can close. That gap is design.

Agents cannot pick a font. They cannot judge whether a bounce animation feels right at 400ms or needs 600ms. They cannot eyeball whether a dark navy background needs a #E2E8F0 or #CBD5E1 text color for readability. They are incapable of opening After Effects and dragging a keyframe.

Today, we are closing that gap. Workshop is now available as native infrastructure for AI agents — through the Model Context Protocol (MCP), through our REST API, and through any LLM that can write text.

Why Agents Need a Compiler, Not a Generator

The instinct is to give agents a generative video model. Type a prompt, get pixels. But anyone who has tried to use AI video generation in production knows the failure modes: the brand colors are wrong, the text is misspelled or illegible, the revision cycle is re-prompting from scratch, and no two generations look the same.

These are not bugs. They are architectural properties of pixel generation. A generative model produces a new artifact every time. There is no persistent specification, no way to change the headline without regenerating the entire video, and no mechanism for brand enforcement.

Agents hit these problems harder than humans do, because agents cannot compensate visually. A human can look at a generated video and say "the blue is off." An agent has no concept of "off." It needs structural guarantees, not visual intuition.

Workshop gives agents a compiler. The agent writes a .ws script — structured text that describes content, mood, and narrative intent. The compiler validates the script, resolves 50+ design parameters deterministically, and produces a RenderGraph that renders to an identical MP4 every time.

The agent does not need to know what font to use. The mood system handles that. The agent does not need to calculate reading speed or entrance timing. The compiler handles that. The agent does not need to ensure brand compliance. The ThemePack handles that.

The agent does what it is good at — reasoning about content and intent — and Workshop does what it is good at — executing design.

How It Works: The Agent Loop

Here is a complete agent workflow, from intent to delivered video:

Step 1: The agent receives a task — "create a product launch video for the new dashboard feature."

Step 2: The agent calls POST /api/author with a natural-language prompt. Workshop's AI authoring layer generates a .ws script, validates it through the compiler, and returns syntactically correct source.

{
  "prompt": "Create a 20-second product launch for our new analytics dashboard. Three scenes: problem, solution, CTA.",
  "mood": "confident",
  "validate": true
}

Step 3: If the agent wants to inspect or modify the script, it can. The .ws source is plain text — the most natural format for any LLM to read, edit, and reason about.

Film "Dashboard Launch"
  mood: confident

Scene "Problem"
  show "You're flying blind."
    size: hero
    enter: rise

Scene "Solution"
  show "Meet the Analytics Dashboard."
    size: display
    emphasis: "Analytics Dashboard"
    enter: fade
  beat 1s
  show "Real-time metrics. Zero setup."
    size: body
    enter: rise

Scene "CTA"
  show "Try it free at apex.dev"
    size: title
    enter: scale

Step 4: The agent calls POST /api/render with the script. Workshop compiles, renders, and returns a job ID. The agent polls until the MP4 is ready, then downloads it.

The entire flow is text in, video out. No visual interface. No design decisions. No asset sourcing. One API call to author, one to render.

The Validation Gate: Why Agents Don't Hallucinate

LLMs hallucinate. In text, this means a wrong fact. In code, this means a syntax error. In video specification, this means a nonexistent entrance animation, an invalid mood name, or impossible timing.

Workshop's validation gate intercepts every LLM-generated script and attempts a headless compilation before the script reaches the caller. If the compiler finds an error — and it will, because LLMs are probabilistic — it feeds the precise error trace back to the LLM for self-correction. The loop continues until compilation succeeds or a retry limit is reached.

The result: every script returned by the /api/author endpoint compiles successfully. The compiler is the oracle. The LLM is the drafter. The agent receives guaranteed-valid output.

This is not prompt engineering. This is structural validation — the same principle that makes typed languages safer than untyped ones, applied to video authoring.

MCP: Video as a Native Agent Capability

For agents built on the Model Context Protocol, Workshop exposes six native tools:

An MCP-connected agent treats Workshop like any other tool in its environment. It can list moods to understand what visual identities are available. It can compile a draft and inspect the scene structure. It can read design tokens to make informed choices. It can generate video without ever leaving its runtime.

This is not a plugin or an integration. It is a native capability. Video becomes something the agent can do, the same way it can search the web or read a file.

Mood: 50 Design Decisions in One Word

The single most important feature for agents is the mood system. A human designer makes dozens of interdependent decisions when creating a video — and they make them through visual intuition that agents do not possess.

Mood collapses those decisions into a single keyword. mood: confident resolves to a complete, internally consistent design system: palette, typography, letter spacing, entrance animations, spring physics, transition behavior, camera movement, post-processing, and timing curves.

Six moods. Five variants per mood. Thirty distinct visual identities. One keyword.

An agent does not need to understand design to select a mood. It needs to understand tone — and tone is something LLMs are excellent at reasoning about. "This is a corporate earnings announcement" → confident. "This is a flash sale" → urgent. "This is a luxury brand reveal" → elegant. The mapping from content intent to visual identity is a language problem, not a design problem.

Brand Safety Without Human Review

Agents producing video at scale creates an obvious governance concern: who ensures the output is on-brand?

Workshop's answer is ThemePacks — brand identity encoded as JSON and enforced by the compiler. When an agent renders video with a ThemePack applied, the compiler overrides mood defaults with your exact brand colors, fonts, and spacing rules. There is no possibility of drift because the constraint is structural, not advisory.

Design and legal approve the ThemePack once. Every video compiled with it is compliant by construction. The agent never sees a color picker. The brand team never reviews individual outputs.

Templates: One Structure, a Thousand Videos

Agents excel at filling in variables. Workshop's template system is built for exactly this.

Register a template with a defined scene structure and variable placeholders. The agent populates the variables from structured data — a product catalog, a CRM record, a campaign brief — and renders. One template becomes a thousand personalized videos.

{
  "template": "product-launch",
  "variables": {
    "headline": "New: Analytics Dashboard",
    "tagline": "Real-time metrics for growing teams",
    "cta": "Start free at apex.dev"
  }
}

Batch rendering supports this at scale. A single API call renders an array of variable sets against one template. The agent submits the batch, polls for completion, and retrieves the videos. No loops, no orchestration complexity.

What This Unlocks

Agentic video creation is not a feature. It is an infrastructure shift.

Personalized video at API scale. An e-commerce agent generates a product video for every SKU in a catalog. A real estate agent creates a walkthrough highlight for every new listing. A SaaS onboarding agent produces a welcome video addressing each customer by name and use case. None of this requires a design team.

Video in agentic workflows. An agent managing a product launch can write the blog post, draft the email campaign, update the landing page, and produce the announcement video — all in one orchestrated run. Video is no longer a separate workstream that blocks the pipeline.

Platform-embedded video. SaaS companies embed Workshop's SDK and expose video creation to their end users. The same infrastructure that powers human editing powers agentic creation. One system, two interfaces, zero design expertise required.

Multi-platform distribution. The same .ws script compiles at any aspect ratio. The agent renders 16:9 for YouTube, 9:16 for Reels, and 1:1 for social — three API calls, same source, same brand.

Try It

Workshop is in public beta. Contact [email protected] for an API key, connect the MCP server, and let your agents create their first video.

• MCP Server and SDK — connect Workshop to any MCP-compatible agent
• AI Authoring — the /api/author endpoint
• Quickstart — zero to MP4 in five minutes
• Batch Rendering — templates at scale