Bubble.io MCP & Agent 2 explained: what AI agents change for your app (and what they won't)
Short answer: MCP (Model Context Protocol) is an open standard that lets AI agents, such as Claude, work directly inside other tools. On October 6, 2026 Bubble launched the Bubble MCP in beta, so agents in tools like Claude Code or Codex can edit existing Bubble apps, together with Agent 2, a faster and more accurate built-in AI Agent. Both make routine work much faster, but agents don't understand your business, data model or security needs, so an experienced Bubble developer stays essential.
In its September 2026 community update, Bubble announced it is opening the platform to AI agents through an MCP interface. The promise, in Bubble's words: external agents will be able to "build and edit your apps on Bubble", with flexibility over which agents and models you use and which parts of your app they can access.
On October 6, 2026 that interface shipped: Bubble launched the Bubble MCP in beta, together with Agent 2 and a new AI credits system. This article covers what launched and answers the question founders are already asking us: if an AI agent can edit my Bubble app, what changes — and do I still need a developer?
What did Bubble launch on October 6, 2026?
Three things, announced together in Bubble's launch post:
- Agent 2. A new version of the built-in AI Agent, available to all users on all apps, web and mobile. Bubble says it is 1.5X better at building exactly what you asked and 2X better at making the result fully functional, partly because it runs the issue checker in the background while it builds.
- The Bubble MCP (beta). For experienced builders who want to edit and grow apps they already have from their own agentic environment, such as Claude Code or Codex. Bubble's examples: pulling Linear or Jira tickets and building the feature, turning Figma or Claude Design mockups into working pages, fixing issues from support tickets and importing apps from other platforms. It uses your own agent, so it doesn't draw on Bubble's AI credits.
- AI credits. Building or editing with the Agent and generating images now use AI credits; generating a new app, working in the visual editor and building through the MCP don't.
| Plan | AI credits included per month |
|---|---|
| Free | 500 |
| Starter | 1,000 |
| Growth | 2,000 |
| Team | 4,000 |
| Agency | 1,000 |
| Enterprise | Custom |
Credits belong to each app, refresh on the first of the month, and extra credits you buy last six months. Apps that existed on October 6 get double their plan's allowance until October 31, 2026. Bubble also announced a new Starter Web price from October 20, 2026; we cover it in Bubble.io pricing explained.
What is MCP?
The Model Context Protocol (MCP) is an open standard, introduced by Anthropic in November 2024, that lets AI agents connect to external tools and data through one common interface. Think of it as a universal adapter: instead of every AI tool needing a custom integration with every app, a tool exposes an MCP interface once, and any MCP-compatible agent can use it.
For Bubble, that means the agent you already use — in a chat app or a coding tool — could read your app's structure and make changes to it, within the permissions you set.
Official Bubble MCP vs community MCP servers
The official Bubble MCP is what Bubble now supports for editing apps, and it is what we'd use for build work. Before it shipped, developers in the Bubble community had published their own MCP servers (one example is this Bubble Forum project). They connect an AI agent to a Bubble app through Bubble's Data API, which means they work with your app's data: reading records, creating and updating them, and in some cases triggering workflows. Most offer a read-only mode.
Two things to know before trying one. They can't build or edit the app itself — pages, workflows and the editor are out of reach — which is what the official Bubble MCP adds. And they run with an API token that grants whatever access you give it, so treat that token like a password, start in read-only mode and never point an experimental server at live customer data.
What does the Bubble MCP make better?
Based on Bubble's launch notes and how MCP works in other tools, these are the realistic gains:
- Faster routine work. Repetitive edits — adding a field across data types, renaming, building a standard CRUD page — are exactly what agents do well. Work that takes an hour by hand can take minutes.
- Plain-language changes. "Add a status filter to the orders page" is a sentence, not a hunt through the editor. That lowers the barrier for founders who maintain their own app.
- Your own AI tools. You work from the agent you already use, such as Claude Code or Codex, and MCP building doesn't use your plan's AI credits.
- Work from where tasks already live. Tickets from Linear or Jira, mockups from Figma, issues from support tickets: the agent can pull them in and build without you copying anything into the editor.
- A narrower gap with vibe coding. The biggest advantage of tools like Lovable was chat-style iteration. With agents editing Bubble apps, you get that speed on a platform with a managed database, auth and hosting. We compared the two approaches in Bubble.io vs Lovable, Replit & Bolt.
What won't MCP fix?
Agents are fast at doing what they're told. The hard part of a Bubble app was never the typing — it's the decisions. These don't go away:
| Area | What an agent does well | What still needs an expert |
|---|---|---|
| Database design | Creates the types and fields you describe | Deciding the structure that will survive growth and new features |
| Privacy rules | Adds rules when asked | Knowing which data must never leak between users, and testing it |
| Workflows | Wires up standard actions | Edge cases, failure handling, backend vs page logic |
| Cost | Builds features quickly | Keeping workload-unit consumption low so the monthly bill stays small |
| Integrations | Configures an API call from docs | Webhooks, retries and what happens when a payment fails |
| Accountability | Makes the change | Reviewing it, and answering for it when something breaks |
Is it safe to let an AI agent edit your Bubble app?
It can be, if you plan for four new risks:
- Access is power. An agent with edit rights can change app logic in seconds. The current MCP can't deploy, merge branches or read logs, so deploying to live stays a human step. Keep it that way: review every change before it goes live.
- Security by prompt isn't security. Privacy rules are what keep one customer's data away from another. An agent will add rules if asked, but it won't notice that you forgot to ask.
- Technical debt at machine speed. A poorly structured app built slowly is a problem; one built in an afternoon is a bigger one. Speed amplifies whatever architecture you start with.
- Hidden running costs. Inefficient searches and workflows consume workload units every month. Agents optimise for "it works", not for your bill — see Bubble.io pricing explained and what that means for maintenance costs.
Does Bubble's AI agent explain what it changed?
Short answer: Yes. Bubble's AI Agent shows a plan before it builds and summarizes what changed when it finishes, and every change is visible in the editor. In Ask mode it waits for your approval before each change. Through MCP, the summary comes from your own agent, such as Claude Code, so ask it to list every change.
According to Bubble's manual, the Agent has three approval modes: Ask (confirms every change), Auto (decides when to ask) and Approve (applies changes without waiting). When it asks, you can approve the plan, cancel it or suggest changes. Bubble also says the Agent "summarizes what changed once it finishes", and version control lets you roll back if a change isn't what you wanted.
A summary is a description, not a guarantee. Our routine on client apps:
- Use Ask mode for anything that touches data types, privacy rules, payments or backend workflows.
- Create a savepoint before each session, so you can roll back the whole session in one step. Records the agent deletes from the development database can't be restored by undo.
- Check privacy rules yourself after every session, in Data → Privacy. They're the one change a summary can make sound fine when it isn't.
- With MCP, end each session by asking your agent for a list of every page, workflow, data type and rule it created or edited, then spot-check that list in the editor before you deploy.
Do you still need a Bubble developer with MCP?
Yes — but you'll use one differently. (If an agent has already left your app in a tangle, our free review is a good place to start.)
We've seen this pattern before. When Bubble launched its own AI generator, apps got started faster — and a new wave of founders arrived with generated apps that looked 80% done and weren't (we wrote about it in Bubble AI built my app — now what?). Agent 2 and the MCP will repeat that on a bigger scale: more apps, built faster, with the same gaps in architecture and security.
What changes is how you use an expert:
- Architect first. An expert designs the database, roles and privacy rules — the foundation the agent then builds on.
- Agent for volume. Routine pages and repetitive edits go to the agent, which lowers the cost of a build.
- Expert for review. Every agent change to logic, data or permissions gets checked before it reaches live users.
- Expert for the hard 20%. Payments, integrations, performance and the edge cases real users find — the problems we list in 9 problems AI can't fix in Bubble.
How to prepare your Bubble app for AI agents
- Clean up the data model. Agents work better on a clear structure. Remove unused types and fields.
- Audit privacy rules. Make sure every data type has rules before any agent gets access.
- Separate development and live. Keep agent changes in development and deploy only after review.
- Document the business rules. A one-page description of what the app must always and never do is the best prompt you'll ever write.
- Decide who reviews. Before you connect an agent, know who checks its work — you, a teammate or your developer.
Frequently asked questions
What is the Bubble.io MCP?
It's Bubble's official interface for the Model Context Protocol, launched in beta on October 6, 2026. It lets experienced builders connect their own AI agent, such as Claude Code or Codex, to an existing Bubble app and build or edit it from there. This version can't read logs, merge branches or deploy.
Is the Bubble MCP available now?
Yes, in beta since October 6, 2026. Setup instructions are in Bubble's manual. Because it runs on your own agent, building through the MCP doesn't use your Bubble plan's AI credits.
Can I connect an AI agent to my Bubble app today?
Yes. The official Bubble MCP (beta) lets your own agent build and edit an existing app. Community-built MCP servers also exist, but they work with your app's data through Bubble's Data API rather than editing the app itself.
What's the difference between Bubble's AI Agent and MCP?
The AI Agent, now Agent 2, is built into the Bubble editor and uses your plan's AI credits. The Bubble MCP lets an external agent you already use, such as Claude Code or Codex, edit your app from outside the editor, and doesn't use Bubble's AI credits.
Will MCP replace Bubble developers?
No. It will speed up routine work, but database design, privacy rules, performance, integrations and reviewing changes still need experience. Faster building makes those decisions more important, not less.
Does Bubble's AI agent explain what it changed after each edit?
Yes. Bubble's AI Agent presents a plan before building and summarizes what changed when it finishes, and every change is visible in the editor. In Ask mode it confirms each change before applying it; Auto and Approve modes ask less often. When you build through the Bubble MCP, the summary comes from your own agent, such as Claude Code, so ask it to list every change and check privacy rules yourself before deploying.
Is it safe to give an AI agent access to my Bubble app?
It can be, with the right setup: the narrowest access that works, privacy rules on every data type, changes made in development and reviewed before deploying to live.
The bottom line
MCP is good news for Bubble users. It brings chat-speed building to a platform that already handles the database, hosting and security infrastructure — the parts vibe-coding tools leave to you. But speed has never been what separates a working app from a fragile one. Architecture, privacy and cost decisions do, and those still need someone who has made them many times before.
If you want to start using the Bubble MCP safely — or want someone to review what an agent has built — talk to us. We'll set up the foundation the agents build on, and check the work they do.
Co-founder and CEO of Webziper. Since 2019 he has led 150+ Bubble.io projects for founders worldwide, from scoping and estimates to launch and support. LinkedIn →