LaunchGrid

Drop a product photo, get the launch: Watch AI agents build your videos, SEO, and ad copy on one visual canvas.

Comment

LaunchGrid: From a Single Image to a Full Video GTM Campaign

Inspiration

Every hackathon has hundreds of AI chatbots. We didn't want to build another one.

Our inspiration came from a real pain point in the solo D2C (Direct-to-Consumer) e-commerce space. When a founder launches a product, they start with a plain white-background photo, but to actually run ads, they need a lifestyle image, a TikTok video, an SEO description, and ad copy.

Currently, founders act as a "Human API," manually copying data between ChatGPT, Midjourney, and Runway, praying the brand voice stays consistent. We asked ourselves: What if we built a visual workspace where you don't write prompts, but instead design the topology of an AI marketing agency, and watch it build the campaign in real-time?

How We Built It

We built LaunchGrid, a node-based visual canvas (built with Next.js and React Flow) that turns a single product image into a complete Go-To-Market kit. We submitted this for Track 2 (AI Showrunner) and Track 3 (Agent Society).

The Core Concept: Spatial Prompting There are no text input boxes. The user drags "Agent Nodes" (Art Director, Video Director, SEO Strategist) onto a canvas and draws wires between them. The wires are the prompts.

If a wire connects the Art Director to the Video Director, our backend strictly follows that visual topology:

  1. Qwen-VL analyzes the raw product image.
  2. Wanx (Image Generation) creates a high-end lifestyle photo.
  3. Wan (Video Generation) takes that image and animates it into a 4-second video.
  4. Qwen-Max acts as our GTM Society—taking the video context and generating perfectly synchronized SEO copy and TikTok scripts.

All of this is powered natively on Alibaba Cloud. We pointed the OpenAI SDK directly at the DashScope compatible-mode/v1 endpoint for text reasoning, while using native fetch for the asynchronous Wan/Wanx media endpoints.

Challenges Faced: Defeating the Latency Bottleneck

Our biggest challenge was managing the severe latency of video generation. Initially, our pipeline treated the Video Director as a synchronous blocker. Because DashScope's Wan API is asynchronous (taking up to 2 minutes to render), the entire downstream graph—including the Scriptwriter and Ad Copywriter—was frozen waiting for an MP4 file.

To fix this, we mathematically treated the canvas as a Directed Acyclic Graph (DAG) and split the Video Director into a "Fast Path" and a "Slow Path."

Let the workflow be defined as a graph $G = (V, E)$. We needed to minimize the Critical Path Latency $L_{crit}$, defined as the maximum sum of node execution times along any path from source to sink: $$L_{crit} = \max_{\text{paths } p \in G} \sum_{v_i \in p} t(v_i)$$

We refactored the Video Director node into two distinct operations:

  1. decideMotionStyle() (Fast Path): Uses Qwen-Max to instantly output the pacing, energy, and visual rationale. Takes ~2 seconds.
  2. startVideoRender() (Slow Path): Kicks off the DashScope video-synthesis job, returning a task_id immediately, and polls it in the background.

We rewired the DAG scheduler so that the graph considers the Video Director "complete" the moment the Fast Path finishes. The Scriptwriter unblocks instantly, using the text rationale instead of the video file.

The Resulting Critical Path Shift:

  • Before (Sequential): Art Dir (15s) $\rightarrow$ Video Render (120s) $\rightarrow$ Scriptwriter (2s) = ~137 seconds of perceived freeze.
  • After (Async Fan-out): Art Dir (15s) $\rightarrow$ Fast Decision (2s) $\rightarrow$ Scriptwriter (2s) $\rightarrow$ Ad Copywriter (2s) = ~21 seconds to a fully completed text campaign, while the video renders silently in the background.

To ensure the frontend didn't freeze, we utilized Server-Sent Events (SSE) with a dual-emit strategy: emitting status: "done" with the text rationale first, and emitting a second status: "done" with the final videoUrl when the background polling resolved. We also implemented a two-stage polling backoff (1.5s for the first 8 polls, then 3s) to prevent DashScope rate limits, and fixed a duration mismatch in the Wan API parameters (hardcoded 10s reduced to 5s).

What We Learned

  1. LLMs shouldn't dictate routing: For production tools, deterministic graph routing (the user's wires) combined with LLM reasoning (the node execution) is vastly superior to letting an LLM autonomously decide which tool to call next.
  2. Decoupling reasoning from rendering: In multimodal AI, text generation is an $\mathcal{O}(1)$ or $\mathcal{O}(seconds)$ operation, while video generation is an $\mathcal{O}(minutes)$ operation. Never gate text-based agents on media-rendering tasks if they only need the context of the media.
  3. The power of Alibaba's Ecosystem: Using Qwen-VL to "see" the product, Wanx to "stage" it, and Wan to "film" it, all stitched together by Qwen-Max's reasoning, proved that the real power of the Qwen ecosystem is how seamlessly these models can be orchestrated in a parallel DAG topology.

Built With

Share this project:

Updates