Seven Days to Ship
How we carved a consumer product out of an enterprise platform in one week.
Enterprise to consumer in one week.
7
Days to ship
97
LLM models available
9
Languages supported
3
Billing providers
February 15, 2026. A Saturday. We had an enterprise platform that our B2B clients had been using for months. Sandboxed AI agents, 97 LLM models, workspace management, the whole stack. What we didn’t have was a product that a single person could sign up for and start using in under a minute.
We’d been watching OpenClaw’s numbers for a while. 157,000 GitHub stars. Thousands of daily active users. A community that keeps growing no matter how many security advisories get published. The demand is real and it isn’t slowing down. People want autonomous AI agents. They want to install a tool, point it at a problem, and walk away.
But we kept seeing the same pattern in our enterprise sales calls. Prospects would say: “We tried OpenClaw internally. It was great until someone’s agent ran rm -rf on a shared volume.” Or: “We loved the flexibility but couldn’t get past the security review.” The appetite was there. The trust wasn’t.
That’s when it clicked. We already had the secure version. Our enterprise platform runs every agent execution in an isolated E2B sandbox. No raw system access, no plaintext API keys, no agent-can-do-anything-it-wants footgun. The trade-off is a little less flexibility — you can’t install arbitrary system packages or mount your home directory. But you also can’t accidentally wipe your filesystem or leak credentials to a malicious skill.
The question wasn’t whether to build a consumer product. It was whether we could strip the enterprise complexity fast enough to ship one. We gave ourselves seven days.
What got cut
The first two days were about subtraction, not addition.
Groups went first. In the enterprise version, every user belongs to an organization, every organization has roles, every role has permissions. For a consumer product, you’re just you. One account, one workspace, your stuff. We built the variant system to strip this entire layer at build time — the code still exists for enterprise clients, it just doesn’t compile into the consumer bundle.
Internal system integrations followed. Jira webhooks, Confluence page imports, custom SSO flows — all enterprise-only. The consumer version connects to the tools individuals actually use: Gmail, Slack, Notion, GitHub.
The admin dashboard stayed enterprise-only. No consumer needs a usage analytics panel with team breakdowns. They need a sidebar that shows their credit balance and a button to buy more.
We could’ve forked the repo. Every instinct says fork it, move fast, clean up later. We didn’t. Instead, we built code path separation into the existing codebase. LikeClaw, Dashboard, FulDive — three products, one repo, different environment configs. Every security patch, every performance fix, every new model hits all variants simultaneously. The cost is a little more complexity in the build. The payoff is never backporting a single line.
Consumer billing from scratch
Enterprise clients pay by invoice. Net 30, purchase orders, the whole ritual. Consumers pay with their thumb on a phone screen.
We already had Stripe and Google Play wired up from earlier work. But Apple wasn’t going to wait. If you want iOS users to buy credits, you need App Store receipt verification, a credit pack UI that makes sense next to the Play Store version, and auto-refresh so the sidebar updates the moment an LLM response lands.
Marina built the entire Apple Store billing integration in three days. Verification endpoint. Credit pack tiles. Test user configs for App Store review. Three billing providers, one unified credit system. The kind of plumbing that’s invisible when it works and catastrophic when it doesn’t.
One-click signup
Enterprise clients get a sales call, a contract, a provisioned account. Consumers get a Google button.
Google OAuth went in on February 18. The flow: frontend redirects to backend, backend handles the Google handshake, callback redirects to the frontend with a session cookie. A @Public decorator on the callback endpoint so the auth middleware doesn’t reject an unauthenticated OAuth redirect. Token caching with date revivers so expired credentials don’t sneak through.
Two days of work. The result: one click to sign up. No passwords, no email verification, no “check your inbox.” The enterprise SSO flow has twelve configuration fields. The consumer flow has a button.
The onboarding problem
This is where enterprise-to-consumer gets hard.
Enterprise users get onboarded by humans. A solutions engineer walks them through workspace setup, connects their integrations, configures their first agent. It takes an afternoon. Nobody complains because the contract is already signed.
Consumer users get sixty seconds before they leave. Maybe less.
The old onboarding was a modal overlay. It popped up, asked you what you wanted to do, and disappeared. Fine for someone who already had a meeting about the product. Useless for someone who just clicked a link.
We ripped it out. Built a dedicated /onboarding route with a multi-screen wizard. The hero screen shows scenario cards: Gmail automation, deep research, code analysis. Each card has a commitment chip — “No Setup,” “OAuth Required,” “API Token” — so you know what you’re signing up for before you commit. The skill selection screen shows curated skills with download counts, star ratings, and author info. Social proof baked into the first sixty seconds.
The trick that tied it together: auto-submit. When you finish the onboarding flow, your selected scenario injects directly into the chat as a prompt. No copy-paste, no “now what” moment. You finish onboarding and the agent is already working.
Nine languages, one day
February 21. Marina added German, Spanish, French, Korean, Portuguese, and Brazilian Portuguese to the frontend. Six languages in a single day. This sounds impossible until you realize our i18n infrastructure had already been battle-tested with English, Russian, Simplified Chinese, and Traditional Chinese. The patterns were in place. The translation pipeline was proven. Adding six more was mechanical, not creative.
Enterprise clients mostly speak English. Consumers speak whatever they speak. Platform parity isn’t optional when you’re launching globally on day one.
The security sweep
The day before launch isn’t the time to discover a security flaw. It’s the time to verify you don’t have one.
We did a full audit of the sandbox boundary. The critical rule: real API keys never enter the E2B sandbox. Not the OpenRouter key, not any provider credential. The sandbox gets a short-lived JWT that routes through our LLM proxy. If the sandbox is compromised, the attacker gets a token that expires before they can do anything with it.
This mattered more for the consumer launch than it ever did for enterprise. Enterprise clients run on private infrastructure behind firewalls. Consumer users run on shared infrastructure on the public internet. The attack surface is wider. The security has to be tighter.
What shipped
97 LLM models available through OpenRouter. Nine languages. Three billing providers. OAuth signup. A new onboarding wizard. Cloudflare Pages frontend. StackSmith backend. Sandbox security hardening. And 15 prompt eval scenarios making sure the AI doesn’t regress while we’re rebuilding everything around it.
Seven days. Two developers. One product that went from “enterprise platform for B2B clients” to “consumer SaaS that anyone can sign up for in thirty seconds.”
The enterprise version didn’t lose a single feature. It gained every improvement we made for consumers — faster onboarding, better skill discovery, tighter sandbox security. The variant system means the two products push each other forward. What we build for individuals makes the enterprise version better. What our enterprise clients demand makes the consumer version more robust.
OpenClaw showed the world that people want AI agents. We’re not arguing with that. We’re offering the same capability with a different contract: your agent runs in a sandbox, your keys stay encrypted, your filesystem stays intact. A little less flexibility. A lot more sleep at night.
Enterprise-to-consumer isn’t a pivot. It’s a second front. Same army, same weapons, wider battlefield.
LikeClaw is live. The enterprise dashboard keeps shipping. Monday we start building for both.
The week, day by day
- 1
Feb 15-16: Cut and deploy
Stripped groups, admin panels, and internal system integrations. Stood up Cloudflare Pages for the frontend and StackSmith for the backend. Built the variant system so enterprise and consumer ship from one repo.
- 2
Feb 17-18: Consumer billing and OAuth
Apple Store billing integration. Google OAuth for one-click signup. Enterprise clients use invoices. Consumers need app store purchases and social login. Different worlds.
- 3
Feb 19-20: Onboarding from scratch
Enterprise users get a sales call and a setup guide. Consumers get sixty seconds. Ripped out the old overlay. Built a multi-screen wizard with scenario cards, commitment chips, and skill selection.
- 4
Feb 21: Localization and security
Six new languages in one day. German, Spanish, French, Korean, Portuguese, Brazilian Portuguese. Then: sandbox security audit. Real API keys never touch the sandbox. Short-lived JWTs only.
- 5
Feb 22: Polish and ship
Onboarding UX refinements. Smart skill sorting. Social proof badges. Dev workflow decoupled into three independent layers. Hit deploy.
Questions about the launch sprint
Why go consumer when enterprise was already working?
Because OpenClaw proved the demand is massive and isn't going away. Thousands of people want autonomous AI agents but can't get past the security problems. We already had the secure version — it just wasn't accessible to individuals. Enterprise pays the bills, but a consumer product builds the brand and creates the champions who bring it into their companies later.
What did you actually cut from the enterprise version?
Groups, role-based access control, integrations with internal systems like Jira and Confluence, SSO configuration, and the admin dashboard. Anything that makes sense for a team of fifty but overwhelms a solo user trying the product for the first time.
How do you ship this fast with two developers?
Small team, zero meetings, one shared codebase. Marina handled backend stabilization, billing, and localization. Alex handled frontend, onboarding, and the eval framework. We reviewed each other's PRs daily. That's it.
Does the enterprise version still get updates?
Every single one. The variant system means one codebase, multiple products. Every security patch, performance fix, and new model lands in both versions simultaneously. Enterprise clients don't lose anything. They gain everything we build for consumers too.