Chinwag

AI production workspace for research, media, and publishing.

Comment

Chinwag: An AI Showrunner Workspace for Research-Backed Media Production

Chinwag is an AI production workspace for the AI Showrunner track. It turns research, source material, and loose creative direction into usable media: scripts, storyboards, clip plans, generated images, Wan video clips, editable timelines, articles, captions, metadata, and publishing packages.

The product bet is simple: AI media generation is not enough on its own. A showrunner needs context, continuity, files, revisions, verification, and a place where each generated asset remains connected to the work that produced it. Chinwag is built around that loop. Sources become research. Research becomes scripts and visual direction. Scripts become clips. Clips become a timeline. The timeline and the surrounding publishing material stay inside the same project.

Track: AI Showrunner

Alibaba Cloud: Qwen, DashScope, Wan video generation, and OSS-backed media storage

Frontend: Next.js workspace

Backend: FastAPI agent backend with Qwen Agent GroupChat

Core idea: make AI production durable enough to revise, verify, and publish.

Inspiration

Most AI creative tools still feel like a beautiful dead end. You can generate a paragraph, an image, or a clip, but the work often falls apart the moment you need the next step: a consistent character, a second shot that matches the first, a file that can be reopened, a timeline that can be edited, or an article package that references the same source material as the video.

Chinwag started from the opposite direction. I wanted the AI system to behave less like a one-off prompt box and more like a production room. A real creative team does not just make an asset. It reads the brief, checks sources, writes the script, builds visual language, verifies what was produced, places it in sequence, and prepares it for release.

That is the shape Chinwag tries to capture. The agents are allowed to create, but the workspace is what keeps creation accountable.

What it does

Chinwag lets a user create a project, add sources, ask agents to research or write from those sources, and then move into Creator Studio to produce media and publishing assets.

For the AI Showrunner workflow, Chinwag can take a premise or source-backed brief and move through the production chain: script, storyboard, shot list, clip plan, image references, generated Wan video clips, timeline placement, and publishing metadata. The same project can also produce articles, newsletters, book packages, thumbnails, captions, descriptions, and release checklists.

User need What Chinwag provides
Understand source material Uploads, linked sources, source inspection, research artifacts, and agent-readable project files
Shape a production idea Scripts, storyboards, shot lists, visual direction, and prompt-ready clip plans
Generate media Qwen Image assets, thumbnails, visual references, and DashScope Wan video clips
Keep clips usable Output verification, MP4 storage, preview state, and timeline placement
Prepare for release Titles, descriptions, captions, article packages, metadata, and publishing checklists

The important part is that outputs are not loose downloads. They become project files in Outputs, with names, types, storage paths, prompt context, and a place in the workbench.

How we built it

Chinwag is a Next.js and FastAPI application built around a durable project workspace. PostgreSQL stores the structured project state. Alibaba Cloud OSS stores the binary files: uploaded sources, generated images, generated video clips, and rendered media. Qwen Agent runs the research and production teams. DashScope provides Qwen image generation and Wan video generation.

Architecture rule: generation should never be treated as the finished product. The product is the chain around it: source, plan, prompt, output, verification, timeline, revision, and publication.

The first architecture decision was to make projects the center of the app. A project has visible folders for Sources, Artifacts, Drafts, Skills, and Outputs. That gives both the user and the agents a shared map of the work. A source PDF, a research artifact, a script draft, a generated image, and a video output are all part of the same workspace instead of being scattered across chat history.

The second decision was to split the agent system into two teams. The newsroom group is led by Maya and focuses on research, source reading, drafting, and time-aware work. Creator mode switches to a production group led by Creator, with Scriptwriter, Picasso, Video, Editor, and Publisher as specialist workers. This matters because a media request is rarely one task. A good video output may need research, script structure, a style anchor, individual clip prompts, generated assets, timeline placement, and release copy.

The third decision was to keep media generation strict. The Video worker does not receive a full manuscript and pretend one model call can make a finished film. Creator first builds a compact clip plan. Each clip has a source beat, target length, size, style continuity, and one production-ready prompt. Clips are generated sequentially. Each one must be saved and verified in Outputs before the next clip or the Editor step can continue.

The fourth decision was to separate preview state from timeline state. A generated video can be opened, previewed, placed, reordered, and combined without losing the underlying output file. The timeline is not just a visual list. It is structured edit state that can be reconstructed from verified project outputs.

Architecture decision Why it matters for AI showrunning
Project folders are first-class Agents and users can point to the same sources, drafts, and outputs
Newsroom and Creator are separate teams Research work and production work can use different specialist behavior
Video generation is clip-based Wan clips stay within model limits and can be verified before sequencing
Outputs are durable files Generated media can be reopened, reused, referenced, and placed in timelines
Timeline edits are structured state The app can preserve assembly decisions instead of treating clips as downloads

Alibaba Cloud in the product

Alibaba Cloud is not just a hosting detail for Chinwag. It is part of the production pipeline.

Qwen powers the agent reasoning path through the Qwen Agent framework and DashScope-compatible model endpoints. DashScope image and video APIs generate the still and moving media assets. OSS stores the source files and generated outputs that the agents inspect, transform, and return to the user. PostgreSQL stores the project metadata that makes those files visible and reusable inside the workspace.

The Alibaba Cloud path works like this:

  1. The user works in the Next.js project workspace.
  2. The FastAPI backend sends research or production requests to Qwen Agent.
  3. Qwen Agent calls project tools to read sources, write artifacts, create drafts, and generate outputs.
  4. DashScope creates Qwen Image assets and Wan video clips.
  5. Alibaba Cloud OSS stores uploaded sources, generated images, generated MP4 clips, and rendered media.
  6. PostgreSQL stores the structured workspace state so the app and agents can find the files again.

This let Chinwag keep the core media loop direct: an agent can read project context, call a generation tool, save the result to OSS, register the output in project state, and stream the result back to the UI.

Creator Studio

Creator Studio is the production surface. Creator acts as the lead. Scriptwriter plans scripts, storyboards, shot lists, and production prompts. Picasso creates still images, thumbnails, key art, and visual references. Video generates Wan clips from short production-ready prompts. Editor places verified clips into the timeline. Publisher turns the work into release material: titles, descriptions, captions, articles, newsletters, book packages, and publishing checklists.

The Creator workflow is:

  1. A brief, source, or draft enters Creator Studio.
  2. Scriptwriter turns it into a script, storyboard, shot list, or clip plan.
  3. Picasso creates visual references, thumbnails, posters, or key art when needed.
  4. Video generates one Wan clip at a time from a production-ready prompt.
  5. Chinwag verifies each saved video output before continuing.
  6. Editor places verified clips into the timeline.
  7. Publisher prepares captions, descriptions, articles, metadata, and release packages.
  8. Finished assets stay in the project's Outputs folder.

This structure became important once video entered the product. A single clip can take time, fail for provider reasons, fail during download, fail during transcode, or fail because the saved output cannot be found. Chinwag treats those as real production states. If a clip fails, the sequence stops with the exact failure instead of quietly skipping ahead and pretending the timeline is complete.

Challenges we ran into

The hardest challenge was making agent work survive large context. A production request might depend on uploaded sources, previous research, a draft, a storyboard, generated images, and a partially built timeline. If the agents treat all of that as loose chat, consistency falls apart. Chinwag had to make the workspace itself carry the context: files, folders, outputs, prompt metadata, and saved artifacts.

The second challenge was consistency across generations. A short drama sequence needs the same character, location, palette, lighting, camera language, and visual style across multiple clips. The solution was not to ask the video model for everything at once. It was to force a clip plan with shared continuity notes, then generate one verified clip at a time.

The third challenge was streaming. Agent work is long-running and uneven. Search may return quickly. A source read may be immediate. Video generation may take minutes. A timeline edit may only make sense after every clip is verified. The UI had to stream reasoning, tool calls, tool results, and errors in a way that kept the user aware of what was happening without hiding failures.

The fourth challenge was video infrastructure. Generated video is not just bytes from an API. It has to be downloaded, checked, transcoded into a browser-safe MP4 when needed, probed for duration, stored, previewed, and reopened later. We hit the very real deployment problem where the backend image could generate the clip but could not finalize it because ffmpeg was missing. The fix was to make ffmpeg and ffprobe explicit deployment dependencies and fail the Docker build if either binary is unavailable.

The fifth challenge was timeline state. A video workbench needs to know the difference between previewing a clip, placing a clip, replacing the timeline, appending to a timeline, and rendering a final output. Keeping those states separate made the product more honest: a generated clip is not automatically an edited video, and a timeline edit should not destroy the underlying output.

Accomplishments that we're proud of

Chinwag is more than a chat box with a media button. It has a real production surface: projects, folders, source upload, source inspection, research agents, writing agents, Creator Studio, image generation, Wan video generation, output verification, Creator Workbench, timeline placement, article packages, captions, metadata, and OSS-backed media files.

I am especially proud of the production discipline around video. The app does not pretend that a long showrunner request can be solved by one generation call. It plans the sequence, constrains each clip, keeps continuity anchors, verifies saved outputs, and only then moves toward timeline assembly.

What feels shippable: Chinwag already has the loop a real AI production workspace needs: gather sources, create drafts, generate assets, verify outputs, assemble timelines, and package the result for release.

What we learned

The biggest learning was that AI generation needs a filesystem-shaped product around it. Creative work becomes usable when it can be named, found, reopened, edited, and connected back to its source material. Without that, even impressive generations feel temporary.

We also learned that agents need narrower jobs than the user request. "Make a video" is too broad. The system needs to break that into research, script, storyboard, clip plan, prompt writing, generation, verification, editing, and publishing. Once those jobs are explicit, the app can fail in the right place and recover from the right place.

Finally, we learned that the unglamorous parts matter. The missing ffmpeg issue was a good example. The model can succeed and the product can still fail if the deployment image cannot transcode or probe the output. For a real production tool, infrastructure dependencies are part of the creative workflow.

What's next for Chinwag

The next step is to make Chinwag more complete as a production operating system. That means stronger timeline rendering, better multi-clip continuity tools, richer output versioning, source-to-output traceability, publishing calendars, team collaboration, and more precise recovery when a long-running generation sequence fails halfway through.

On the technical side, the next work is to harden the deployment and media pipeline: registry-based image promotion, deeper observability for agent runs, background job handling for long video tasks, stronger signed URL handling, and durable job state so long generations can survive browser refreshes and server restarts.

Next area Direction
Video timeline More edit operations, render controls, transitions, audio support, and version history
Continuity Character sheets, style bibles, reusable location notes, and clip-to-clip consistency checks
Production memory Better traceability from source to draft to prompt to generated asset
Reliability Durable job queues, provider retry policy, richer logs, and clearer failure recovery
Publishing Platform-specific packages for TikTok, Instagram, YouTube, newsletters, and articles

Public build writeup

Chinwag was built for Track 2: AI Showrunner in the Global AI Hackathon Series, using Alibaba Cloud as the backbone for Qwen agents, DashScope media generation, Wan video generation, and OSS-backed project files.

Built With

Share this project:

Updates