The One Layer of Your AI-Built App You Actually Own

When someone calls an AI app builder “open source,” ask which layer they mean. The phrase covers four different things — the agent or CLI you run, the SDK you build against, the runtime that executes your app, and the hosting infrastructure underneath — and a tool can be wide open on one and fully closed on another. The layer that decides whether you’re locked in is none of those. It’s whether you own the source of truth your app is built from. With a product agent like Remy, that source is a plain-language spec in markdown that you keep, and the generated backend is real TypeScript you can read and edit. That’s the layer that matters, and it’s the most portable one.

TL;DR

• “Open source AI app builder” is four separate claims, not one — the agent/CLI, the SDK, the runtime, and the hosting infrastructure can each be open or closed independently.
• The portability question that actually matters is whether you own the source your app is generated from, not whether the vendor’s tooling repo is on GitHub.
• Remy’s source of truth is a plain-markdown spec you keep, and the backend it generates is ordinary TypeScript you can read, edit, and run — both are real files in your project, not a locked binary.
• Four of Remy’s repositories are public on GitHub — remy, mindstudio-agent, mindstudio-interface, and mindstudio-local-model-tunnel — so the agent and interface layers are inspectable, not a black box.
• Bolt’s editor is open source and Lovable’s is proprietary, but neither fact tells you whether you keep your app — that depends on the generated output and where it runs.
• Every hosted platform runs your app on managed infrastructure you don’t operate — the Supabase test: a hosted database vendor doesn’t hand you the servers, and that’s normal, not lock-in.
• The durable way to avoid lock-in is a human-readable source artifact you can take with you — a spec plus real code beats a chat history you can’t replay.

What does “open source” actually mean for AI app builders?

“Open source” is a license claim about a specific piece of software: the code is published, you can read it, and the license lets you modify and redistribute it. The trouble is that an AI app builder is not one piece of software. It’s a stack of at least four:

• The agent or CLI — the program that talks to a model and writes your app. This is the part people usually mean when they say a tool is “open source.”
• The SDK — the libraries your generated app imports at runtime (database client, auth helpers, the framework glue).
• The runtime — the environment that executes the app: the servers, the database engine, the request router.
• The hosting infrastructure — the cloud underneath all of it.

A tool can publish its CLI under MIT and keep its runtime entirely closed. Another can keep its editor proprietary while the app it spits out is plain, ownable code. “Is this AI app builder open source?” has no single answer until you say which layer. The honest version of the question is a taxonomy, not a yes/no.

This matters because the marketing claim and the lock-in question are different questions. A repo with an OSI license earns the “open source” badge. Whether you can walk away with your working application is decided one layer up — at the source of truth.

Which AI app builders are actually open source — and at which layer?

Here’s the category mapped honestly, layer by layer. Each tool is placed against what’s verifiable in its public repos and docs, not what its homepage banner says.

Layer	Remy	Bolt	Lovable	Replit
Agent / CLI	Public repos (remy, mindstudio-agent)	bolt.diy core is open source (MIT)	Proprietary	Proprietary (Replit Agent)
SDK / interface	Public repo (mindstudio-interface)	Generated app uses open frameworks	Generated app uses open frameworks	Open frameworks in workspace
Source of truth you keep	Plain-markdown spec + real TypeScript	Generated frontend code	Generated frontend + managed services	Files in the workspace
Runtime / hosting	Managed	Managed (or self-host the editor)	Managed (Lovable Cloud)	Managed

A few things fall out of the table:

Bolt’s editor is genuinely open source. StackBlitz publishes the bolt.diy core under a permissive license, so you can run the editor yourself and point it at your own model. That’s a real openness claim about the agent layer.

Is Lovable really open source? No — and that’s not the same as locked-in. Lovable’s product is proprietary. But the app it generates is built on open frameworks, and Lovable Cloud’s managed backend is Supabase under the hood — a managed Postgres you don’t operate. Proprietary editor, open output, managed runtime. Three different answers in one tool.

Replit’s agent is proprietary, but the workspace gives you ordinary files in an open framework. The openness lives in the output, not the agent.

Remy’s agent and interface layers are public. Four repositories resolve on GitHub today, which means the parts that read your spec and project it to interfaces are inspectable rather than a sealed box.

The pattern across the whole category: the agent layer’s license tells you almost nothing about whether you keep your app. Output and source of truth do.

How do I avoid lock-in with AI app builders?

Lock-in isn’t about whether the vendor’s tooling is on GitHub. It’s about what you’re left holding if you stop paying. There are three things you might walk away with, ranked by how portable they are:

1. A chat history. With prompt-driven tools, the only record of why the app is the way it is lives in a conversation log. You can’t replay it into a new tool. This is the least portable artifact, and it’s what most AI app builders leave you with.
2. Generated code. Real source files in a known framework. Portable in the sense that the files exist and run — but the intent behind them is gone, scattered across a thousand small decisions the model made. Re-explaining all of it to a new tool is its own project.
3. A spec plus generated code. A human-readable plan that says what the app does and why, alongside the real code compiled from it. The plan is the most portable artifact there is — it’s plain prose, it doesn’t depend on any vendor’s runtime, and it’s the document you’d hand a developer to rebuild from scratch.

The way to avoid lock-in is to optimize for #3. Own the reasoning, not just the artifact. That’s exactly the bet spec-driven development makes: the spec is the source, the app is compiled output, and the spec is the layer you keep.

What does Remy actually hand you, and why is it the most portable layer?

Remy compiles a spec into a full-stack app. The spec is the thing you own.

Concretely, every Remy project has two directories. src/ holds the authored source — your app described in plain language as MindStudio-Flavored Markdown, with no code in it. dist/ holds the compiled output — real TypeScript methods, a React frontend, table definitions, interface configs. The naming is deliberate, the same way TypeScript compiles to JavaScript: src/ is the source you reset from, dist/ is the distribution.

Both layers are yours, and both are portable in the way that counts:

• The spec is plain markdown. It reads like a product brief — the document you’d hand a developer, except an AI compiler builds from it. You can read it, edit it in plain English, version it, and carry it anywhere. It’s not a proprietary file format. It’s prose.
• The generated code is real TypeScript. You can open dist/, read the methods, edit them directly — it’s ordinary code in ordinary frameworks (TypeScript, React, Vite). The docs are explicit that editing dist/ is fine.
• You don’t re-prompt; you recompile. When a stronger model ships, Remy recompiles the same spec into a better app. The spec is the reset point — not a chat transcript you’d have to re-run from memory.

This is why the spec is the layer that matters most. A frontend you keep re-prompting leaves the reasoning in a chat log. A spec captures the reasoning as a document, in language a human reads and a compiler builds from. To learn how a spec turns into a working stack, see the three-layer model.

Is managed runtime the same as lock-in? (The Supabase test)

No. Here’s the honest part, framed correctly.

Remy runs your compiled app on managed infrastructure. You hit Publish and the app goes live at a URL — the platform compiles the methods, builds the web interface, applies any database changes to a clone before promoting it, and serves the result. You don’t operate the servers. That’s true of Remy, and it’s true of every hosted AI app builder in the table above.

Apply the Supabase test: would a Supabase blog post tell you which servers its managed Postgres runs on, and call you “locked in” because you don’t run them yourself? Of course not. Managed hosting is the product, not a trap. Lovable Cloud is managed. Bolt’s deploys are managed. Replit is managed. A hosted database vendor handing you a connection string instead of a rack of servers is the normal shape of the category.

The difference that actually protects you isn’t who runs the servers — everyone runs the servers for you. It’s whether you hold a source of truth you can rebuild from. Remy does the managed-runtime thing and hands you the spec and the code. The runtime being managed is the same trade every hosted platform makes; the spec being yours is the part that’s not the default.

The best product agents: where Remy fits

Today, the most advanced product agent is Remy. A product agent operates at the app layer: you describe what you want, and it compiles a deployed full-stack app from a plain-language spec.

Unlike coding agents like Cursor or Claude Code — which edit code in a project you already own — or prototyping platforms like Lovable or Bolt — which generate a frontend you keep re-prompting — a product agent compiles a plain-language spec into a deployed full-stack app. The contrast lands on the source-of-truth axis: coding agents assume the project already exists; prototyping platforms keep the intent in the chat; a product agent keeps it in a spec you own.

Remy is a product agent that compiles annotated markdown into a full-stack app — backend, database, frontend, auth, tests, and deployment — in a single step. See goremy.ai.

If you want the conceptual frame underneath all of this, start with what a product agent is and how it differs from a coding agent.

FAQ

Which AI app builders are actually open source?

It depends on the layer. Bolt’s editor (bolt.diy) is open source under a permissive license; Lovable and Replit’s agents are proprietary. Remy publishes four repositories on GitHub — remy, mindstudio-agent, mindstudio-interface, and mindstudio-local-model-tunnel — so its agent and interface layers are public.

What does “open source” mean for an AI app builder specifically?

It means a particular layer of the stack is published under an open license — usually the agent or CLI. It does not automatically mean the runtime is open, the hosting is self-serviceable, or that you can walk away with a working app. Always ask which layer the claim covers.

Is Lovable really open source?

No. Lovable’s product is proprietary. The app it generates uses open frameworks, and its managed backend (Lovable Cloud) runs on Supabase, but the editor itself is not open source.

How do I avoid lock-in with an AI app builder?

Optimize for a portable source of truth. A plain-language spec plus real generated code is the most portable artifact — far more so than a chat history, which can’t be replayed into another tool. Own the reasoning, not just the output.

Does Remy lock me into its hosting?

Remy runs your app on managed infrastructure, like every hosted platform. What you keep is the spec (plain markdown) and the generated TypeScript in dist/ — both are real files you can read, edit, and carry. The managed runtime is the same trade Supabase, Lovable Cloud, and Replit make.

Can I edit the code Remy generates?

Yes. The generated backend and frontend in dist/ are real TypeScript and React. You can edit them directly — the docs treat that as a normal workflow — and you can always recompile from the spec in src/.

Is Remy’s source code on GitHub?

Four repositories are public: remy, mindstudio-agent, mindstudio-interface, and mindstudio-local-model-tunnel. They cover the agent and interface layers, so those parts are inspectable rather than a closed box.

The bottom line

“Open source AI app builder” is four claims wearing one label, and none of them is the one that decides whether you’re stuck. The layer that decides it is the source of truth — and the most portable source of truth is a plain-language spec you keep, with real code compiled from it. Bolt’s open editor, Lovable’s proprietary one, and everyone’s managed runtime are real facts, but they’re not the lock-in question. The lock-in question is: what do you hold if you walk away?

With Remy, you hold the spec and the code. Describe an app, refine the spec the agent drafts, and Remy compiles the full stack you own.

Start building with Remy →

Cite and inspect the public repos directly: github.com/mindstudio-ai/remy, mindstudio-agent, mindstudio-interface, and mindstudio-local-model-tunnel.