Most AI apps are wrappers, and you're paying the markup

Tap “Generate” in a typical AI photo app and here is what actually happens. Your selfie leaves your phone for the app’s servers. The app forwards it, wrapped in a prompt template you never see, to a GPU it rents by the second from a company you’ve never heard of. The model runs, the image comes back through the same two hops, and roughly three cents of inference lands in your camera roll. You paid about ten cents of your subscription for it.

That gap is the business model of most consumer AI apps, and this post is a tour of it: who the middlemen are, what each hop costs you in money and in privacy, and the two ways to shorten the chain. One cuts the markup. The other removes the middleman entirely.

Your AI app probably doesn’t run any AI

Under most AI products sits an inference aggregator: a company that racks the GPUs, hosts hundreds of models behind one API, and bills by the image, the video-second, or the token. Replicate says thousands of businesses build on it, and its homepage names names: Character.ai, Photo.ai, Headshot Pro, Magnific. Runware advertises 400,000+ models behind a single API. fal, Together, and OpenRouter round out the layer. When a new AI app launches on a Tuesday, odds are its “proprietary AI” went live by signing up for one of these on the Monday.

What does the app itself contribute? Usually four things: an interface, a prompt template (the “professional headshot, studio lighting” boilerplate wrapped around your selfie), some content filtering, and a billing system. That’s a real product. It is also a thin one. The capability you’re actually paying for, the thing that turns your selfie into a headshot, lives two companies away and is available to anyone with a credit card. Which is why the same aggregator can power a dozen near-identical apps at once, each with its own branding, mascot, and price.

None of this is a scandal. Aggregators are legitimate, excellent infrastructure; nobody should have to rack H100s to ship an app, any more than a cafe should grow its own coffee. The consumer AI economy that a16z’s Top 100 Gen AI Consumer Apps report tracks (March 2026 edition: ChatGPT alone at 900 million weekly users) was largely built on rented inference, and built fast because of it.

But the shape of the chain matters to you, the person at the top of it, for two reasons. Every hop adds a cost you can’t see. And every hop adds a server that handles your data under terms you didn’t read. Take them in order.

You pay retail for inference the app buys wholesale

The strange thing about the AI supply chain is that the wholesale prices are public. Aggregators publish their menus the way gas stations post theirs, so the markup math is one division away.

Run that division on a typical credit pack. An app selling 100 image generations for $9.99 a month charges about 10¢ an image. If it generates with a mid-tier model like FLUX Dev at Replicate’s 2.5¢ list price, you’re paying a 4x markup. If it uses a budget model on Runware, where images start at $0.0006, the markup can pass 100x. And that assumes you use every credit; the ones that expire unused are pure margin.

Credits are the tell, incidentally. A credit is a currency whose exchange rate only the app knows: how many cents of inference one credit buys, which model it buys it from, and whether that model quietly got cheaper this quarter while your pack price didn’t. Aggregator prices have fallen steadily; wholesale image generation that cost a nickel in 2024 costs a fraction of a cent on the budget tier today. When the input gets 10x cheaper and your subscription doesn’t move, the difference didn’t vanish. It became margin.

To be fair about what the margin buys: interface, prompt engineering, support, and the ads that got you to install the thing. Wrappers do real work, and charging for it is business, not fraud. The point is narrower. The line item you think of as “paying for AI” is mostly paying for packaging, and once you know the wholesale number, you can decide per job whether the packaging is worth 4x. We priced a full hour of mixed AI work at wholesale rates in What one hour of serious AI use actually costs; the totals surprise most subscribers.

Every hop keeps a copy of your data

The second cost never shows up on an invoice. Your prompt, your selfie, your uploaded contract: each one transits every server in the chain. The app sees it, the aggregator sees it, the model provider sees it, and each of the three handles it under a different policy. You agreed to exactly one of them, and you probably didn’t read that one.

Make it concrete. Upload twenty photos of your face to a headshot app and the pictures land first on the app’s storage, where its terms govern them. They’re forwarded to the aggregator’s GPUs, where its data policy takes over. If the underlying model is a proprietary one, a third company’s API terms apply on the last hop. Three companies now hold, or have held, your face. Ask the app “where do my photos go?” and the honest answer spans three legal documents, two of which the app didn’t write and can’t amend.

The policies are not reassuring when you do read them. Consumer AI surfaces routinely reserve broad rights: Google’s own Gemini Apps privacy hub discloses that a subset of chats goes to human reviewers and that reviewed conversations are kept for up to three years, even if you delete your activity. The infrastructure layer can be vaguer: Replicate’s privacy policy, for one, states retention lasts “as long as necessary” without a specific window for inference inputs and outputs. A wrapper app stacks its own terms on top of all that, often with the classic “we may use your inputs to improve our services” clause.

None of this means anyone in the chain is misbehaving. It means exposure is multiplicative. Every additional company that handles your data is an additional breach surface, an additional subpoena target, and an additional terms-of-service update you won’t notice. The privacy question about an AI app is not “is this company trustworthy” but “how many companies am I being asked to trust.”

Bring your own key and the markup disappears

The first fix follows directly from the public menus: connect to the provider yourself. Apps built on a bring-your-own-key model let you paste in your own API key, and every call is billed by the provider at its published rate. The app charges for its software, once or on its own terms, instead of quietly reselling inference inside a subscription.

The infrastructure layer itself shows how thin honest routing margins actually are. OpenRouter, the biggest LLM router, passes through provider pricing with no markup on inference and makes its money on a disclosed 5.5% credit-card fee, plus 5% if you bring your own provider key. Single-digit percent, printed in the docs. Compare that with the 300 to 10,000 percent implied by a credit pack, and you see where in the chain the real margin hides: not at the infrastructure layer, at the packaging layer.

BYOK shortens the data path too. With your own key, calls can go from your machine to the provider directly, cutting the app’s servers out of the loop entirely. To be precise about what it doesn’t fix: an aggregator may still sit in the cloud path, and the provider still processes your data. You’ve removed the retail layer, not the cloud. The full ledger of what BYOK changes, in dollars and in ownership, is in BYOK vs. SaaS AI.

Local models fire the middleman entirely

The second fix is the one the wrapper economy has no answer to: run the model on your own hardware. Open-weight models (Qwen, Gemma, DeepSeek, Llama, and dozens more) are free downloads, and a current laptop runs the mid-sized ones well. Set one up and the supply chain collapses to a single link. No app server, no aggregator, no provider. No per-call billing, so “unlimited” stops being a marketing tier and becomes a fact about your electricity. And nothing leaves the machine: the privacy policy stack from the last section shrinks to zero documents.

The catch used to be quality, and it’s fading fast. Today’s open-weight tier handles the daily 80% of AI work (drafting, summarizing, coding help, image generation at the quality most social posts need) at a level that was frontier-class two years ago. Our field guide to the best open models you can run right now maps the current roster to the RAM you have, tier by tier.

The hardware bar is lower than the wrapper economy would like you to believe. A 16 GB laptop, which is to say a normal laptop, runs the small and mid-sized language models comfortably; 32 GB and up opens the tier where local output stops feeling like a compromise. Image generation asks more of a GPU, and the biggest open models remain workstation territory. But “can my machine run it” is a subtraction, not a mystery, and the answer for most machines bought in the last three years is yes to more than their owners think.

The cloud still earns its place for the hardest jobs

Honesty requires the caveat: local does not win everything. The hardest reasoning problems, the longest documents, and premium video generation still belong to frontier cloud models; nothing you can download today matches Veo 3, and Veo 3 costs a very cloud-shaped $0.40 per second at fal’s list price. The realistic architecture for a serious AI user in 2026 is hybrid: local by default for the daily 80%, cloud at wholesale for the 20% that genuinely needs a frontier model.

Notice what that stance rejects. It doesn’t reject the cloud, and it doesn’t reject paying for good software. It rejects exactly one thing: paying a permanent retail markup on a commodity with a published wholesale price.

Five questions that X-ray any AI app

You can audit any AI product you currently pay for in about ten minutes. The five questions below expose the supply chain behind the interface, and apps with good answers tend to volunteer them: transparent products brag about their architecture, because it’s a selling point. Silence is information too. An app that won’t say which model it runs is usually protecting a swap option: the freedom to move your generations to a cheaper model later without telling you. That’s exactly the trade a credit shields from view, and exactly the one a posted wholesale price would expose.

For the record, this blog’s publisher is a worked example of the architecture this post argues for, so here is its X-ray. CSuite’s cloud models run on the same aggregators named above, Replicate and Runware, with one difference: you connect your own keys and pay their public list prices, with no CSuite margin on any call, and calls go from your machine to the provider without touching our servers. Local models run through Ollama and Hugging Face runtimes for nothing, forever, offline. The software is a one-time license instead of a subscription, because the packaging should be paid for as packaging.

Whatever tools you choose, keep the frame: the model is a commodity with a posted price, and everything between you and it is packaging. Pay for packaging when it earns its keep. Just never let anyone sell you the commodity at 4x and call it magic.