DEV Community: LI QINYU

OpenAI Codex Sites: the launch layer arrives — inside your company workspace

LI QINYU — Tue, 16 Jun 2026 23:50:53 +0000

When the company that ships the best coding agents also ships "prompt → hosted web app," that is not a competitor showing up. That is the strongest validation yet that agents need a launch layer.

OpenAI's Codex Sites lets an agent turn a prompt into a running, hosted web app — login-gated, with a real database underneath — without you touching a deploy pipeline. That is the "deploy" half of launching an agent-built app, and OpenAI solved it cleanly, inside ChatGPT.

But launching a product is two halves. Deploy is one. Public and paid is the other — a public URL anyone can open, public signup, and a way for the people who use your app to pay for it. Codex Sites stops at the first half. It has no public links, no custom domains, and no payments at all. That second half is exactly what SettleMesh does.

What Codex Sites actually is

Codex Sites went into preview on 2026-06-02. You describe a site or app, the agent builds it, and OpenAI hosts it. Under the hood it runs on Cloudflare Workers, with D1 for the database and R2 for storage. For internal tools — a dashboard for your team, an ops console, a quick data viewer your coworkers need to log into — this is genuinely good. The friction from "agent wrote it" to "it's live and my team can use it" basically disappears. The constraint is who can reach it, and what they can do once they're there.

Availability. Codex Sites is available in ChatGPT Business and Enterprise workspaces (Business on by default; Enterprise via admin RBAC). Plus, Pro, Free, and API tiers don't have it. It's locked inside your company workspace: to use Codex Sites, and to reach what it builds, you generally have to be inside that workspace.

Sharing. A Codex Site can be shared three ways — with admins, with everyone in the workspace, or with named members. All three are scoped to your workspace. There is no "anyone with the link" public mode. That's the line between an internal tool and a product. A product is something a stranger can find, open, and use.

End-user login. Because access is workspace-scoped, the person logging in has to be a workspace member or come through your pre-configured IdP. There's no open public signup the way a normal product has.

Payments. None. Codex Sites has no payment, billing, or monetization capability of any kind. There is no path from "users use this" to "users pay for this."

The fact table (verified June 2026)

Dimension	Codex Sites (preview)	SettleMesh
Availability	ChatGPT Business + Enterprise only (not Plus / Pro / Free / API)	Everyone — install the CLI from npm and go
Sharing	Three modes, all scoped to the workspace. No "anyone with the link" public mode	Public URL, reachable by anyone
End-user login	Must be a workspace member or provisioned via your IdP	Public signup and login, out of the box
Custom domains	None (OpenAI-owned addresses)	Platform subdomain out of the box (custom domains on the roadmap)
Payments / billing	None	Usage billing + user wallet + end-user-pays + hosted checkout
Stack	Cloudflare-Worker-compatible ES modules; D1 + R2	Static / SPA / container (any language) + managed DB and storage

Read the table as a story, not a scorecard. OpenAI built a fast, clean path to a hosted, login-gated app for your coworkers. SettleMesh builds the path to a public, paid product for your users. Both are launch layers. They aim at different halves of "launch."

The half that's still wide open

After Codex Sites, an agent can produce a hosted app your workspace can log into. What it still can't do, by design:

Give that app a public URL a stranger can open.
Let that stranger sign up and log in without being added to your org.
Charge that stranger anything — there is no payments layer to charge with.

That last one is where most agent-built apps quietly die. Your AI app burns money on every API call — charge your users for it, per use, without building billing. That's metered billing plus end-user-pays: the end user who runs the expensive call is the one who pays for it.

Here's the four-line version of the other half:

npm i -g settlemesh
settlemesh login
settlemesh deploy
# live: public app with login, a managed database, and usage billing

One command takes an agent-written app — built with any agent, Codex included — and turns it into a public product. Public URL. Public signup and login. Usage-based billing. End-user payments through hosted checkout. Aev is SettleMesh's prepaid credit unit (1 USD = 100 Aev, funded via Stripe): users top up a wallet, and every metered call quotes its cost before it runs and settles against the wallet after.

Who actually lets your AI app charge users

Codex Sites is the newest entrant, but it's not the only tool that gets you most of the way and stops short of payments. The question that matters — can the people who use your app pay you?

Product	Publish	End-user login	Payments	Key limitation
Codex Sites	Inside workspace	Workspace / IdP	None	Business/Enterprise preview, no public links
Lovable	Free to publish	Built in (Supabase)	Subscriptions + one-time, gated to Pro+; no usage billing	Custom domains on Pro+
Bolt.new	Free (with badge)	Via Supabase	Stripe integration; no usage billing	Billing logic lives in generated code
Vercel v0	Free to publish	No native auth	Stripe via generated code	Two layers of billing (v0 + Vercel)
Replit	Free, 1 app, sleeps after 30 days	Yes	Integrated	Realistically needs Core at ~$20-25/mo
SettleMesh	Free tier is enough to ship	Built-in public signup	Hosted usage billing + wallet + end-user-pays	The money path is managed, not generated code

Where the builders offer payments at all, they hand you a Stripe integration or generate billing code, and they mean subscriptions or one-time charges. None give you usage billing — charge per call, per video, per request — as a managed layer. That's the model an AI app actually needs, because the cost an AI app incurs is per use, not per month.

This isn't a roadmap promise

The SettleMesh money paths are already running in production: discrete cost-plus markup (m between 1.0 and 1.5), the unified per-user Aev wallet, end-user-pays via the X-Settle-Payer header, nested billing, and the owner revenue split — with the end-user-pays charge flow verified on a live app. The part that's genuinely a moving target is Codex Sites itself — it's in preview.

The bigger picture

OpenAI shipping Codex Sites tells you the industry now agrees on the shape of the problem: agents build apps fast, and the bottleneck moved downstream to launching them. They solved the inside-the-workspace half. The public-and-paid half is open, and it's the half that turns an agent's output into a product with users and revenue. And it composes: today's deployed app is tomorrow's composable API — every paid app on the mesh can become a capability the next agent calls and pays for.

Try it at settlemesh.io — build with any agent (Claude Code, Codex, Hermes, OpenClaw, Cursor), then settlemesh deploy for the public, paid half.

Build with any agent. Launch with SettleMesh.

SettleMesh is a product of StructureIntelligence Inc. — settlemesh.io · github.com/StructureIntelligence. Aev is SettleMesh's prepaid credit unit: 1 USD = 100 Aev, funded via Stripe.

Why AI coding agents need a launch layer

LI QINYU — Tue, 16 Jun 2026 23:00:48 +0000

The coding got 10x faster. The launching didn't.

Point a coding agent at a half-formed idea and it will hand you a working app before your coffee is cold. Backend, frontend, schema, a couple of API integrations, tests that pass. The part that used to take a week of focused work now takes an afternoon of prompting. That much is real, and you've felt it.

Then you try to ship the thing, and time stops moving.

Because the agent didn't write the part that turns code into a product. It wrote the business logic. It did not provision the database, register the OAuth app, wire the session store, set up the billing meter, or figure out how a stranger pays you. None of that is the app. All of it stands between the app and your first paying user. The bottleneck moved. It's no longer the code. It's the economic shell the code has to live inside.

That shell is the new scarce thing. This essay is about why, and what closes the gap.

The real cost: from "agent finished the app" to "first paying user"

Let's walk it concretely, because "ops glue" is exactly the kind of phrase that hides how much work it is.

Deploy the backend. Deploying a backend in 2026 still means: create the service, pick a region, write a Dockerfile, set the env vars, provision a database, wire the connection string, configure health checks, point a domain at it, add TLS. Each step is individually boring and collectively a day. Your agent finished the application logic an hour ago. It's now idle while you play sysadmin.

Add login. Adding "Sign in with Google" to a project that an agent built in an afternoon means: register an OAuth app, configure the redirect URIs, handle the callback, store sessions, hash something, and read forty minutes of provider docs you will forget by next week. Login is table stakes for anything with users. It should be part of deploy. It almost never is.

Get a managed database. The agent assumed a database exists. Now you provision one, manage its credentials, keep them out of the repo, run migrations, and worry about backups. More accounts, more dashboards, more secrets to rotate.

Bill for usage. This is where it gets genuinely hard, and where most side projects quietly die. Stripe gives you primitives, not metered billing. An AI app that meters usage needs: usage events, aggregation, a credit balance, top-ups, refunds when a call fails, idempotency so a retry doesn't double-charge. That is two to four weeks of work you spend not building product, getting the edge cases wrong, and never quite trusting the numbers.

Make the end user pay. Here's the one that breaks the whole economic model for AI apps, and almost nobody talks about it. Your app calls an LLM, generates a video, scrapes a page — every call costs you real money. In the demo, you eat that cost. In production, every signup makes you poorer. To survive you have to pass the per-call cost through to the user who triggered it. Doing that yourself means tracking cost per request, attributing it to the right person, and settling it against a balance you also had to build. Most demos skip this entirely. It's the boring part: who pays?

Add it up. The agent wrote the product in an afternoon. The shell around the product — deploy, login, database, metered billing, end-user payments — is the week that follows, and it's the same week every single time, for every app. It's undifferentiated. It's identical across projects. And it is precisely the work that does not get cheaper when the code gets cheaper.

That asymmetry is the whole problem. Production collapsed. The shell didn't.

What a launch layer is

A launch layer is the missing half. It's the layer that takes the app your agent wrote and ships it as a product — with login, a database, usage billing, and end-user payments already attached — from one command. Not a deploy tool with billing bolted on later. The shell, delivered with the deploy.

The differentiator, and the reason this matters most for AI apps specifically, is metered, end-user-pays billing:

Your AI app burns money on every API call. Charge your users for it — per use, without building billing.

Concretely, with SettleMesh that's two things you don't build:

Metered billing as a manifest flag. The two-to-four-week billing project — usage events, aggregation, balances, top-ups, refunds on failure, idempotency — collapses to billing.enabled: true. Every metered call is priced before it runs and recorded against a balance.
End-user-pays, with a header. When your app does work on behalf of a user, attach X-Settle-Payer and the cost lands on their balance, not yours. The per-call cost of the LLM, the render, the scrape flows through to the person who triggered it. Your app stops getting poorer with every signup.

Underneath sits a prepaid credit unit called Aev (1 USD = 100 Aev, topped up through Stripe), a unified per-user wallet, and a settlement engine that splits revenue to the app's owner automatically. You write the app. The launch layer handles who's signed in, what they used, what it cost, and who pays whom.

It's agent-agnostic by design. Whatever coding agent you already reach for — Claude Code, Codex, Hermes, OpenClaw, Cursor, or whatever you pick up next — writes the code. There's nothing to integrate and no SDK to adopt: the agent just runs settlemesh deploy. The tagline is the shape of it: build with any agent, launch with SettleMesh. The launch layer does everything between "it works on my machine" and "a stranger just paid me."

settlemesh deploy
# app live, login wired, database provisioned,
# metered billing on, end-user payments ready

That's the gap, closed.

Why now

This isn't a tooling preference. It's a structural shift, and it has three steps.

Production is collapsing toward zero. Agents are driving the marginal cost of producing software down by orders of magnitude. The number of apps in the world is about to exceed the human radius of management by a wide margin. When anyone can generate a working app in an afternoon, generating the app stops being the scarce, valuable act.

So structure becomes the scarce thing. When production is no longer scarce, what's scarce is everything around production — who's using a piece of software (identity), how much they used (metering), who pays whom (settlement), and how it gets found and combined with other software (distribution). The economic shell. The exact week of glue we just walked through. Cheap code makes that shell more valuable, not less, because there's vastly more code that needs it and the same fixed cost to wrap each piece.

And the existing commerce layer can't serve it. Subscriptions, contracts, app-store 30% cuts, week-long review cycles — all of it was designed for human-speed, human-scale commerce. It cannot underwrite an economy of minute-scale creation, micro-amounts, high frequency, and machine-to-machine calls. When an agent builds an app that calls another agent's app a thousand times an hour, there is no human in the loop to sign a contract or approve an invoice. The commerce layer we have was never built for that traffic.

That's the case for a native settlement layer — billing and payments that run at agent speed instead of human speed. That's the position a launch layer fills.

This is live, not a roadmap promise

The fair question about anything in this space is: is this vaporware, and is agent-built code even a real product? So here's the honest accounting.

The core of the system is already running in production. Not designed, not planned — running:

Discrete cost-plus markup, m between 1.0 and 1.5 — every metered call priced on real, known cost.
A unified per-user Aev wallet — one balance per user, funded via Stripe.
End-user-pays via X-Settle-Payer — the cost of a call lands on the triggering user, not the developer.
Nested billing — an app that calls another app settles correctly down the chain.
Owner revenue split — the app owner's cut is computed and settled automatically.

There are real apps running on this shell today — a video-editing app with a working wallet loop, a YouTube-transcript app running Whisper end to end, an agent-built MovieAgent — each one deployed, paid, and settled through the live machinery.

What's not done yet is density — the number of nodes on the network. That's the honest gap, and it's the one thing a launch layer earns by being used rather than by being built. The economics underneath are real today.

If you build AI apps, the pitch is narrow and concrete: stop eating your own API costs, stop spending the same shell-building week on every project, and charge your users per use without writing a billing system. settlemesh deploy, and the shell comes with the deploy.

And one step further out, because cheap production rearranges what software even is: today's deployed app is tomorrow's composable API. Every app shipped through the launch layer arrives already metered and settled, which means the next agent can call it, pay for it per use, and build on top of it without a contract or an integration meeting. The network grows itself.

Try it at settlemesh.io. Build with any agent — Claude Code, Codex, Hermes, OpenClaw, Cursor, or whatever's next — then settlemesh deploy, and the launch layer ships with it.

Build with any agent. Launch with SettleMesh.

SettleMesh is a product of StructureIntelligence Inc. — settlemesh.io · github.com/StructureIntelligence. Aev is SettleMesh's prepaid credit unit: 1 USD = 100 Aev, funded via Stripe.