On 20 April 2026 I specced a node canvas for branded image and video generation. On 4 June 2026 ElevenLabs shipped Flows. Neither of us saw the other's work. When two people draw the same box six weeks apart, the box is not the idea. The problem underneath it is.
Two independent teams reached the same interface for the same reason: generative work is a pipeline, and pipelines want to be seen. I built mine to escape subscription pricing and keep a per-use cost model, which is exactly the model ElevenLabs already runs on.
The canvas is right. Two things are still missing from it: prompts are documents now, not strings, and the canvas should have a model inside it that can read and edit the whole graph.
Underneath all of it: software is going headless. The model does the work, the human keeps the taste, and the interface stops being somewhere you type and becomes somewhere you decide.
This is not a claim about priority. It is a claim about inevitability, which is far more interesting. Priority is luck. Inevitability tells you the problem is real and the shape of the answer is already settled.
I am not claiming I got there first in any meaningful sense. Six weeks is noise, and they shipped a product to real users while I was building a tool for myself and a handful of clients. The point is that neither of us invented the canvas. We both walked into the same wall and drew the same diagram on it.
The wall is this: generative work is not a prompt, it is a pipeline. One good image is a lucky prompt. A hundred on-brand images, consistent across a campaign, produced next month by someone who is not you, is a system with inputs, branches, checks and a review step. The moment you take that seriously, you need to see the whole thing at once. A chat window cannot show you a pipeline. A canvas can.
The honest origin of BrandFlow was not a product thesis. It was a bill. Every tool in the creative stack had quietly become a subscription, each one priced for a studio, each one billing whether or not I opened it that month.
Subscriptions and creative work are badly matched. Creative output is spiky: nothing for three weeks, then two days where you generate four hundred assets. A monthly fee charges you for the flat line and caps you at the spike, which is precisely backwards. It also quietly changes the product's incentive. A subscription needs you to come back tomorrow. A per-use tool is allowed to be finished with you.
Wiring the model APIs directly fixed that. I pay for tokens and generations, the cost tracks the work, and a quiet month costs nothing. It also made me model-agnostic by accident, which turned out to be the more valuable outcome. I route to whichever model is currently best for the job: Google's are, in my view, the strongest image and video models per pound right now and I reach them through fal, Claude drives the language and the orchestration, and ElevenLabs does the voice. None of those choices are permanent, and that is the entire point. The frontier moves every few weeks. Anything welded to one provider is depreciating.
ElevenLabs already sells the correct way. Credits, priced per use, scaling with the work rather than the calendar. When I found myself building my own tooling to escape subscription pricing, I was building toward the model they already run. That is a large part of why I use them.
Offered in the spirit of someone who built the same thing and hit the same walls. Both of these are things I got wrong in my own version first, and both are, I think, the difference between a canvas you demo and a canvas you work in all day.
The text field is the single most-used object on the canvas and it is almost always sized for a sentence. Real prompts are not sentences. Mine run to paragraphs: brand rules, negative constraints, reference notes, style scaffolding, a worked example. Editing that through a small fixed box means everyone drifts back out to a text editor and pastes in, which breaks the canvas as a working surface.
Ask: resizable, multi-line, markdown-aware prompt fields. Let the node grow with the thought. Soft-wrap, a monospace option, and a way to fold long sections so a dense graph stays legible.
Right now a graph is built by hand, node by node. But the graph is structured data, and structured data is exactly what a foundation model is good at reading and rewriting. If the canvas exposed its graph over an API or an MCP server, I could point Claude at the whole flow and say: add a variant branch for portrait, tighten every prompt to the brand rules, tell me which node is burning the most credit for the least output.
Ask: a companion model with read and write access to the graph, via MCP. Authoring, refactoring and critique, not just generation.
The second one is the bigger idea and it generalises well beyond Flows. Once a product's state is legible to a model, the product acquires a second interface for free: the one where you describe the change instead of performing it. Most software has not noticed this yet. The ones that do will feel a generation ahead.
The reason both canvases appeared at the same time is that the job of an interface is changing underneath all of us, and nobody has fully redrawn it yet.
Interfaces were designed for a world where the human supplied the labour. Forms, fields, toolbars, menus: places to put the work in. When the model supplies the labour, that entire vocabulary is aimed at the wrong problem. You do not need somewhere to type four hundred prompts. You need somewhere to set the intent, watch the spend, and reject the nine outputs that are not good enough.
So software goes headless first. The capability becomes an API, addressable by a model, composable with anything else. Then a thin interface is drawn back on top, but only at the points where a human genuinely adds something: judgement, taste, permission, and the decision to stop. That is why the node canvas survives the transition while the toolbar does not. A canvas is a review surface. A toolbar is a data-entry surface, and data entry is the part being automated.
Which means the scarce skill stops being production and becomes discrimination. Telling good from great, quickly, at volume, and being able to say why. Interfaces should be designed to make that judgement fast: show me the variants side by side, show me what changed, show me what it cost, let me kill eight of them in one gesture.
This is the least glamorous shift and the one I think about most. When generating ten thousand words costs nothing, the constraint moves entirely to the person who has to read them.
So I have become genuinely opinionated about the shape of long-form output, in a way I never was before. Everything I build writes to markdown, because markdown is the one format that a model, a terminal, a website and a person can all read without translation. It has become the lingua franca of the whole stack almost by accident, and it is now the first thing I design.
This page is built to that spec, which is the only honest way to argue for it. TL;DR at the top, the conclusion before the evidence, one idea per section, and nothing bolded that is not load-bearing.
The practical method behind all of the above, because a thesis about pace is worthless if the work is slow.
None of this is theory. BrandFlow exists because the pricing annoyed me, Say It exists because a thousand-day Duolingo streak left me unable to order a beer, and both were built in the evenings against real deadlines. The canvas was inevitable. What you do on top of it is not.
See BrandFlow Studio →