B2C App Builder

Build the business around the app.

Primitives for creating, launching, and improving consumer-app businesses.

Get started · Documentation · Architecture · Contribute

A consumer business needs more than an app that compiles. It needs a product people want, a distinctive experience, a working funnel, and reliable monetization. It needs a way to learn what works and improve.

B2C App Builder gives AI agents a shared foundation for that whole business. It is laid out like a restaurant kitchen. Stations are the responsibilities every consumer-app business has, and they do not change with the app. Capabilities define what each station must produce. Providers implement them. Recipes arrange the work into creation and operating loops. Selected knowledge is the mise en place that helps the agent decide well. You are the executive chef. You choose the opportunity and the product, set the bar, and let your agents cook. The ethos explains the stations and who runs them.

The goal is to move human attention from building one app to designing and testing businesses. Produce one excellent consumer business first. Then reuse its foundations for a different approach to the same market, with comparable evidence.

Get started

Use Node.js 24.

npm install -g b2c-app-builder
b2c setup

Setup creates the local workspace registry and prints the MCP registration command for Claude Code, Cursor, and Codex. The portable form needs no install at all:

claude mcp add --scope user b2c-app-builder -- npx -y -p b2c-app-builder b2c-app-builder-mcp

To work from source instead, clone the repository and run the same setup:

git clone https://github.com/Clueless-Creations/b2c-app-builder.git
cd b2c-app-builder
npm ci
npm run setup

From a checkout, setup runs npm link, so b2c resolves to that checkout. Either way, the first commands are the same:

# List the public capabilities, providers, and recipes.
b2c catalog --json

# Preview a composition. This creates and changes nothing.
b2c compose --config contracts/public-api/examples/subscription-app.json --json

The preview resolves each operation to a provider and lists any blockers. This declaration preview reports canApply: false. To activate an installed package recipe, use the separate revision-checked composition plan and activation commands. The b2c-app-builder skill routes broad consumer-app work to the right workflow.

Then give the agent a mandate:

Research a consumer problem in this market. Define a differentiated product. Design and build its native app and web funnel. Establish the evidence we need to improve it. Review, repair, and prove it is ready.

The business-building guide walks through the product workflow, design decisions, and release boundaries.

The public lifecycle creates a planning workspace, initializes its accepted product with the 99-workflow complete-business recipe, plans eligible work, and runs bounded sessions through the existing executor. Evidence reports separate current acceptance from missing or stale proof. Interrupted requests close through revision-checked recovery after uncertain effects are reconciled. See the lifecycle contract for commands, revisions, request replay, and recovery.

Related MCP server: Loxo

What it covers

Each area has workflow and knowledge coverage. See Status for what is implemented today.

How it fits together

A provider swap does not redefine what an entitlement means. A different analytics tool does not redefine activation. A new recipe reuses the same execution and evidence machinery. Shared foundations should make distinctive apps easier to build. Builders keep control of product, brand, business model, and operating loop.

A composition binds a recipe to a target. It can override the provider for a single operation:

apiVersion: b2c/v1
recipe:
  id: b2c/subscription-app
  version: 1.0.0
target:
  platform: ios
  runtime: swiftui
bindings:
  b2c/monetization.present-paywall:
    provider:
      id: b2c/revenuecat
      version: 1.0.0
    connection: connection:paywalls

Save this as b2c.yaml and run b2c compose --config b2c.yaml --json. Every other operation uses the recipe default. Connection values are names of separately managed connections, never credentials. The architectural shape shows how a request moves through entrypoints, contracts, composition, execution, and evidence.

Sheet 3 draws that binding as one station. The purveyor can change, and the operation keeps its meaning.

Public interface · Generated schemas · Extension guide

Operate the app

Mobile app operation is a capability of its own. Agents use it to walk customer journeys, reproduce bugs, review design, and capture screenshots or demo footage. The default provider is the agent host's native simulator tooling. MobAI or another provider can be selected when its coverage fits the task better. The mobile app operation guide covers provider selection and what counts as evidence.

Example quality

Tuck shows real app and web captures, including trip planning, packing, and the landing page. The gallery links capture provenance and verification limits.

Status

Declared support, a working implementation, and a launch-ready business are separate facts. This table reports the first two.

Open source and credits

The builder runs and wraps open-source projects, adapts published methods, and offers one optional managed provider. ACKNOWLEDGMENTS.md credits the projects and people behind that work. THIRD_PARTY_NOTICES.md carries the legal notices for material the builder incorporates. Both files are rendered from the upstream manifests under catalog/upstreams. Workers never receive credits as instructions.

Contribute

Contribute a better consumer-app reference, an operation contract, a provider, or a recipe. Contributors build the kitchen and the way it runs. Most contributions add a way to run a station, not a new station. First-party and community extensions pass the same conformance suite. Start with the extension guide, then CONTRIBUTING.md. Agents read AGENTS.md first. It routes by scope: one business uses b2c-app-builder, a reusable contribution uses b2c-contributor, and the builder itself uses b2c-maintainer.

MIT licensed.