Orchestrator,
not aggregator.

The default

Almost every generative-AI tool for creative work makes its money the same way: it sits between you and the model, and it charges you for passing through. Credits. Compute units. "Images included." A subscription that folds a markup on every generation into one round monthly number.

It is a rational business. The model providers publish their prices; the tool buys at wholesale, sells at retail, and the difference pays for the product. Nobody is hiding anything. But look at what the arrangement does to incentives. A tool paid per generation earns more when you generate more. It earns on the re-run you did not need, on the twelfth variation you never opened, on the revision round that changed three shots and re-billed twelve. Its interest and yours point in opposite directions, and a product built on that foundation will, over time, be shaped by it.

We run an archviz studio. We pay those meters ourselves, on real deadlines, and for a long time we could not tell what a revision round had actually cost us, or which tool had quietly re-billed what. That is where Brut started.

What Brut does instead

Brut never sits in the call path. You bring your own API keys: Google, OpenAI, Anthropic, Kling, the rest. They live in your operating system's keychain, on your machine. When you run a graph, each request goes from your computer straight to the provider, on your key, at the provider's published price. There is no server of ours in between. Not a proxy, not a relay, not a "convenience" endpoint. The engine that orchestrates everything runs on your own machine, on the loopback address, and could not forward your traffic through us if we wanted it to, because there is nothing of ours to forward to.

The ledger is the proof. Every project keeps one: every generation, which provider received the money, how much. The last line reads the same on every project we have ever run.

Never pay twice

Zero markup is the principle. Caching is where it turns into money.

Brut hashes every node's inputs. Re-run a graph after a client note and only the nodes whose inputs actually changed call a provider; everything else is served from your disk, for nothing. Re-roll one tile of a twelve-shot contact sheet and eleven stay cached. Pin a result you liked last Tuesday and it is free on every run until you unpin it.

This is the feature an aggregator cannot ship. Not technically: technically it is trivial. Commercially. A business that earns on volume cannot build a product whose first job is to reduce it. We can, because we sell the tool, not the tokens.

What we sell, then

Orchestration. The canvas where a render becomes a dusk study, becomes a curated set, becomes a film. The review loop: contact sheets, keep and reject marks, boards, the per-shot re-roll. The confirm dialog that itemizes every cent before it is spent. The catalog, kept current while providers rename their models every quarter. The companion that learns your taste and never bills a key without a human click.

A flat price for that, when the beta ends. Generation at cost, forever. The two numbers will never be blended into one, because the moment they are, you can no longer see which is which.

What Brut is for

Brut is an exploration tool. It runs in production, on client deliverables, every week; but its first job is not the final image. It is the twelve viewpoints you would not have had time to try, the dusk study before the client asks for it, the short film cut from stills that used to stay stills. It makes a working artist faster and braver. It does not make one unnecessary.

That deserves saying plainly, because the debate is loud. Nothing in Brut ships without a human choosing it: the contact sheet is curated by hand, every paid run stops at a confirm, the keep mark is yours. And the tool is only as good as what you feed it. Give it a careless render and a lazy prompt and you get careless results, faster. Give it the eye of someone who has spent years learning what a good image is, and it multiplies that eye. The craft was never the bottleneck we wanted to remove. The waiting was.

Bright lines

Things Brut will not do, under any pressure, at any stage:

• Sell credits, meter generation, or mark up API resale.
• Host generation "for convenience" on a server we pay for.
• Hold your keys anywhere but your own machine.
• Cap generation itself. Your key is the only meter.
• Sell usage data. The only thing Brut ever sends home is a heartbeat: version, OS, an install id. Never content, never a prompt, never a file name.
• Hold your work hostage. Graphs, outputs, ledgers and keys are files on your own disk. Whatever happens to a subscription, they stay readable and yours.

One honest footnote. Where a first-party API does not exist for you (payment rails, launch lag, a model only sold through a reseller), Brut lets you route that model through an aggregator you subscribe to yourself, on your own credential. It is explicit, chosen, and flagged on every node and every ledger line: "runs via …". Your own key takes over the moment you add one. We take nothing either way.

What it costs us

We should say plainly what this decision gives up. Onboarding is harder: you need provider accounts with billing enabled, and a free tier that answers your first call with a quota error is yours to fix. We cannot say "images included". We cannot smooth a first experience with tokens we bought in bulk. We earn nothing on your busiest month.

We accept all of it, because the alternative is a tool whose success depends on your waste, and we would not want to be its customer either.

Why a studio

Brut exists because we needed it on real deadlines, and every node in it answers a production pain we actually hit: the twelve-viewpoint study, the revision round, the facade lettering that silently blocked every shot until we bisected the inputs to find it, the client under NDA whose tower could not touch a cloud. It is built inside the work, on the work, and it will keep being built that way.