Like many developers, we started with the obvious idea.
"Let's expose everything."
Every model.
Every setting.
Every parameter.
Every generation endpoint.
If our AI filmmaking platform could do it, the API should be able to do it too.
Simple.
Or so we thought.
The more power we exposed...
...the less interesting the results became.
Not because the models weren't capable.
Not because the API wasn't well designed.
But because we had accidentally removed the most important part of the filmmaking process:
The human.
An API doesn't know what story you're trying to tell.
Generating an image is easy.
Generating a technically correct storyboard is also relatively easy.
Generating a sequence that has pacing, emotion, visual rhythm, continuity, composition and intent?
That's a completely different problem.
People often imagine an endpoint like this:
POST /generate-movie
Reality is closer to this:
- Write a story.
- Break it into scenes.
- Split scenes into individual shots.
- Decide what deserves a close-up.
- Decide where the camera should move.
- Introduce characters gradually.
- Maintain visual continuity.
- Keep costumes, locations and props consistent.
- Refine prompts.
- Throw half of them away.
- Iterate again.
Only then do you press "Generate."
We discovered something unexpected.
Our application wasn't valuable because it could generate images.
Lots of products can do that.
It was valuable because the UI quietly guided people through hundreds of tiny creative decisions.
The software constantly asks questions.
"Should this really be one shot?"
"Would this scene work better from another angle?"
"Is this character already established?"
"Does the audience know where they are?"
These aren't API parameters.
They're creative decisions.
Could we expose all of this?
Technically?
Absolutely.
We could probably expose another hundred endpoints tomorrow.
The problem isn't building endpoints.
The problem is that an endpoint cannot replace a creative workflow.
You can expose every knob and dial imaginable, but that doesn't automatically produce better content.
Sometimes it produces the opposite.
AI slop at incredible speed.
So why build the API at all?
Because there are brilliant people who will use it in ways we never imagined.
Someone might integrate it into an educational platform.
Someone else into a game engine.
Or a production management system.
Or an entirely different creative workflow.
Those people already have the human in the loop.
We're simply giving them building blocks.
That's probably the biggest lesson we learned.
Building an API isn't just exposing functionality.
It's deciding which parts belong to software...
...and which parts should remain human.
Right now, we believe the best films still come from a collaboration between humans and AI—not from pressing one magical "Generate Movie" button.
Maybe that changes one day.
Until then, we'll keep building tools that make creators faster, not obsolete.
If you're interested in building on top of our AI filmmaking platform, the public API is available here:
I'm curious how other developers approach this problem. Have you found good ways of exposing creative workflows through APIs without losing the human element?