Building reliable AI workflows, not generating content
The part of Vionto worth showing publicly was never the video output — it was how the pipeline handles failure.
fixtures/assets.json). The interactive pipeline below runs the real engine in your browser, with zero network calls. Runnable harness: benchmarks/vionto.What was ported, what wasn't
| Stage | Stack | Core idea | Where it hit a wall |
|---|---|---|---|
| Personal project | Next.js · Prisma/Postgres · BullMQ/Redis · FFmpeg · OpenAI/Anthropic | Turn a brief into a rendered photo/video story: LLM script generation, a render-worker queue, subtitle burn-in, audio mixing. | The interesting engineering — a job state machine, idempotent retry, schema-validated manifests — was entangled with live provider calls, real media, and infrastructure that can't be shown publicly as-is. |
| This benchmark | Pure state machine · fixture providers · structured render reports · no live calls | Extract the orchestration discipline — approval gates, idempotent retry, seeded-failure recovery, cost estimation — and prove it deterministically, without a queue, a render farm, or a single API key. | Deliberately no live provider adapters, no real media encoding, no worker infrastructure. The public benchmark demonstrates reliability discipline, not content generation. |
How the benchmark is built
Every stage's output is schema-validated before the pipeline advances. A malformed asset plan is caught immediately — never silently passed to a render stage that would waste the expensive step.
The state machine will not proceed past script generation or asset planning without an explicit approve() call. A human can reject at either gate and the run ends cleanly at cancelled — never silently continuing with rejected output.
Retry is legal only from failed or cancelled, and always returns a new job rather than mutating history — the same rule the legacy render-job retry route enforced, generalized to every stage.
The state machine, providers, and renderer are one ESM module imported by the Node test suite, the fixture generator, and the Showcase's client-side Pipeline Explorer — no second implementation to drift.
What we gave up, and why
The public surface cannot call a real LLM or render worker. That rules out 'generate my own video' demos, but it's the only way to publish a pipeline benchmark with zero API keys and zero cost risk.
The fixture renderer produces a JSON report and an SVG storyboard strip, not an actual encoded video — there is no media pipeline dependency in this benchmark, synthetic or otherwise.
Lessons from the legacy system
The legacy retry route got idempotency right in one place. Making it a first-class, tested state machine — rather than logic embedded in one API route — is what let this benchmark prove the rule holds for every stage, not just render.
An estimate nobody checks against reality isn't a benchmark dimension, it's a guess. Recomputing 'observed' cost from the actual artifacts — and reporting the delta as zero in fixture mode, honestly — sets up the exact comparison a live adapter would need to earn trust.
- Real provider adapters (an LLM for scripts, a render worker for video) implementing the same ScriptProvider/RenderProvider interface, gated behind explicit flags and a cost confirmation step.
- Real asset storage, licensing, and rights verification for any non-synthetic media.
- Durable queue/worker infrastructure so a job survives a process restart, with the same state machine and idempotent-retry semantics enforced server-side.
- Audit logging and access control around who can approve or reject a run at each gate.