Feelm Studio

One idea in, a finished film out, produced by five AI agents who research, write, shoot, score, and cut like a real crew.

Comment

Inspiration

Every AI video tool I tried had the same flaw: change one thing and it regenerates everything on faith. Rewrite a line and your hand-tuned shot list is gone. Nudge the tone and the whole film re-renders. Real film production isn't like that — a crew hands off structured work, and a script note doesn't trigger a reshoot of the entire movie.

The other thing: "AI agents" usually means one model in a trench coat wearing five hats. I wanted an actual crew — a Director, a Writer, a Cinematographer, a Composer, an Editor — that specializes, collaborates, and disagrees the way people do.

The name is feel + film: films that move someone, made with a human touch.

What it does

Feelm Studio takes a one-line idea to a finished film. A Researcher (Parallel Search API) fact-checks the idea first. The Director sets the creative brief. The Writer drafts a grounded script. The Cinematographer plans every shot, the Composer scores it (real audio via Lyria), the Editor assembles the cut. Scenes render as images (Gemini) and image-to-video (Veo). A Python ADK "Executive Producer" agent orchestrates the pipeline, each step an HTTP call to the studio API.

Every asset — scene, script line, shot plan, image, clip, score — is a node in an explicit dependency graph. Change the brief and only the scenes that actually used it get flagged stale. Hand edits are never silently overwritten.

And in Agent Rooms, the crew talks. For any scene, the five agents deliberate — thinking aloud, asking each other for their discipline's eye, answering — and each one distils a craft lesson that carries into every future film. The Writer literally gets better at being the Writer.

How I built it

A TypeScript monorepo: @osai/core (the graph engine, mutation-tested before any UI existed), @osai/inference (model adapters behind one fixed contract), a Hono API, and a React 19 studio. Python + google-adk for the orchestrator. Everything runs on Vertex AI — Gemini 2.5 Flash for text, Gemini's multimodal model for images, Lyria-002 for music, Veo 3.1 Fast for video. It ships as a single Cloud Run container that serves both the API and the built studio. 283 Vitest tests, TDD throughout.

What I learned

  • Modeling the project as a dependency graph is the part a competitor can't copy without rebuilding the engine — precise staleness, reproducible version history, and protected hand edits all fall out of it for free.
  • Vertex model availability is per-project roulette: Imagen 404'd, so images route through Gemini's generateContent; veo-3.0-fast 404'd, veo-3.1-fast worked. You have to probe live.
  • With Parallel Search, the objective phrasing is everything — "common misconceptions" pulled junk; "authentic real-world detail" pulled grounding a script could actually use.
  • A tiny mechanism — each agent keeping one lesson per scene — compounds. The discussion is one cheap LLM call; the distilled lesson pays off on every project after it.

Challenges I ran into

  • Model 404 roulette on Vertex — solved by live-probing and switching image generation to Gemini's multimodal endpoint.
  • Video that shook — the Ken Burns fallback had pixel-snap jitter; fixed with a 4× supersample before the zoom/pan and motion spanning the whole clip.
  • Staleness that stays precise through merge / split / rewrite of scenes — solved as an identity-matching problem, not a renumbering one.
  • Keeping the ADK step order guaranteed while letting the LLM drive — the ordering lives in pipeline.py; the agent narrates and makes the creative calls inside each step.
  • "Agents discuss" vs. "never silently regenerate" — the per-scene deliberation stays observational; only the distilled cross-project lessons feed back into the agents' prompts.

Accomplishments that we're proud of

  • The graph engine. Every asset is a node with real dependencies, so staleness is precise — change the brief and only the scenes that used it get flagged, never "everything downstream." Hand-edited work is never silently overwritten, and a scene keeps its identity through a merge, split, or full rewrite. It was mutation-tested before a single line of UI existed.
  • A crew, not a costume. Five agents that genuinely specialize and hand off structured work — Director → Writer → Cinematographer → Composer → Editor — with a Parallel Search Researcher fact-checking the idea before the Writer ever drafts.
  • Agent Rooms. The agents deliberate on a scene — asking each other for their discipline's read, answering, disagreeing — and each one keeps a craft lesson that persists across every future project and folds into its prompts. As far as we can tell, nothing else does this.
  • All the way onto Google Cloud. Text, image, music, and video generation on Vertex AI (Gemini, Lyria, Veo), a Python ADK orchestrator, and the whole studio in one Cloud Run container — built out from a local-only prototype in about three days.
  • 283 tests, TDD throughout — moved fast without leaving a mess.

What we learned

  • Graph-first pays for itself. The trust behaviors users actually care about — precise staleness, protected hand edits, reproducible history — aren't features you build one by one. They fall out of modeling the project correctly once.
  • Real agent collaboration needs a substrate. Agents can't just chat; they need a shared, structured artifact to hand off through. The dependency graph and the deliberation log are what make five agents a crew instead of five prompts.
  • Small compounding mechanisms beat big ones. One craft lesson per scene, kept forever, shifts the output more than a longer prompt ever did.
  • Cloud model availability is not uniform. Imagen 404'd for our project; veo-3.0-fast 404'd; both had working substitutes. Adapters behind one fixed contract turned each surprise into a one-line swap.
  • For retrieval, the objective phrasing matters more than the model. With Parallel Search, "authentic real-world detail" pulled grounding a script could use; "common misconceptions" pulled noise.
  • Expensive agent behavior should be on-demand. Visible, user-triggered, cost-bounded — deliberation runs when you ask for it, never silently in the background.

What's next for Feelm Studio

  • Deploy the orchestrator to Vertex AI Agent Engine: today the ADK "Executive Producer" runs via adk run against the hosted studio API; next it becomes a managed agent.
  • Real narration. A Cloud TTS voice for the Voice Actor : the one pipeline stage still on a stub.
  • Persistent craft memory. Move the cross-project lesson store from a local file to Firestore so agents keep getting better on the hosted deploy, not just locally.
  • Templates : saved presets for aspect ratio, voice, visual style, and approval posture, so high-volume Shorts creators can batch-produce.
  • Brand collections for agencies : client-scoped logo, palette, font, and approved voice that never leak across clients, plus importing client footage as a first-class timeline node.
  • Deliberation with teeth. Optionally let a Room huddle emit concrete notes that regenerate a scene, not just discuss it.
  • Finishing tools as graph nodes : color grade, subtitles, and transitions with the same precise-staleness guarantees as everything else.

Built With

Share this project:

Updates

Submission history