Emergent vs Lovable (2026)

The build agent wires outside services into each app in two ways. Integrations with a playbook follow a tested setup recipe for services such as Stripe, PayPal, Shopify, Razorpay, Paystack, SendGrid, Resend, Twilio, ElevenLabs and the OpenAI, Anthropic and Google models, and a few bill a small credit fee per run.

Anything else with a public API is coded in against the customer's own key. Teams can also register their own MCP servers under Manage Agents, giving the agent tools to read schemas, run queries, post to Slack or open Jira tickets while it builds. Servers are entered as JSON in the mcpServers format, and each tool list is cached for five minutes.

Sourcehelp.emergent.sh/connect-your-toolsread 2026-10-09

Connectors sit in a single catalog, with Lovable handling authentication, credentials and requests. There are three connection types, app connectors, chat connectors and app user connectors, where each person using the published app connects their own account, and each connector's page says which types it supports.

About ninety integrations have their own pages, spanning Salesforce, HubSpot, Pipedrive and Zoho CRM, Snowflake, BigQuery, Databricks, Redshift, ClickHouse and Microsoft Fabric, Shopify, WooCommerce, PrestaShop and Lightspeed, Stripe, Chargebee, QuickBooks and Xero, Slack, Twilio, Telegram and Resend, Workday and Ashby, Aikido and Wiz, Notion, Airtable and Contentful, and AWS S3. An any API route, a create connector path, custom MCP servers and MCP registries cover anything not listed.

Sourcedocs.lovable.dev integrations introduction, app-connectors, chat-connectors, app-user-connectors, any-api, create-connector and integration catalogread 2026-08-31

Every conversation runs as a long lived Temporal workflow in which the agent reasons, calls a tool, reads the result and repeats, up to 10,000 tool calls per message and four hours of wall clock time. A main agent plans the work and spawns subagents for testing, design, code review and integration setup, which run in parallel workflows and report back.

Three agents set the workflow when a job starts: E-1 builds step by step, E-2 checks that the pieces it builds fit together, and E-3 runs E-1 as a subagent under its own loop for large, open ended goals. Runs end on named stop reasons such as end_turn, handoff, max_iterations and insufficient_credits, and a handoff passes the task to another agent.

Sourcehelp.emergent.sh/how-the-agent-runs-workflow-stop-reasonsread 2026-10-09

Build mode, formerly Agent mode, works on its own and takes a task end to end. It understands intent, explores the codebase for context, applies changes across files and resolves issues during development, with visible tasks showing progress and results reviewed before moving on.

Plan mode handles decisions, and the user can switch between the two at any time. Subagents are a separate feature, and cross project referencing lets one project draw on another. Skills apply reusable instructions, code mode and the project editor expose generated files for direct editing, and drafts and project history support iteration.

Sourcedocs.lovable.dev agent-mode, plan-mode, subagents, cross-project-referencing, skills, code-mode, projects/editor, drafts and projects/history pagesread 2026-08-31

Work reaches the builder when a person sends a message. A builder picks an app type (Full Stack App, Mobile App, Landing Page or Brainstorm), chooses an agent and types a prompt in the web workspace at app.emergent.sh or its mobile web app, and a new job can also start from an imported GitHub repository. In Plan mode the build waits until the plan is approved. On the self serve plans nothing starts a build on a schedule, a webhook or an event, so the agent works only while someone is driving it. The apps it makes can run scheduled jobs of their own once published.

Sourcehelp.emergent.sh/start-with-your-idearead 2026-10-09

Lovable can check a project on a schedule, daily or weekly at a chosen time and optionally only after a minimum number of edits, reviewing the app code for broken functionality and recent visitor errors, then alerting by email and listing findings to fix in the project chat. So the builder agent wakes on a schedule without anyone asking. Other routes in are the web chat, a Slack app, mobile and desktop apps, a Telegram route, the Lovable API and the Lovable MCP server. Monitoring is in beta, on Pro, Business and Enterprise.

Sourcedocs.lovable.dev project-monitoring page and llms.txt indexread 2026-09-29

Each build draws on the job's own material: the whole conversation, the workspace code and files, the database structure, the key names in .env, and files attached to chat such as screenshots, Figma exports, PDFs, CSVs and specs. MCP servers add schemas, documents and live rows from outside systems. Pro raises the context window to one million tokens, long chats are compacted automatically, and a fork starts from an editable summary of the history. Context is gathered for each run from these sources, and the builder keeps no searchable index of a company's wider documents.

Sourcehelp.emergent.sh/a-tour-of-the-workspaceread 2026-10-09

Knowledge holds persistent instructions and context for the agent, defined once and always included, at two levels. Workspace knowledge holds shared rules across all projects, such as coding standards, preferred libraries and naming conventions, and project knowledge holds the app's purpose, database schema, architecture decisions and domain terminology. Workspace knowledge is a text field, unlike Skills, which load on demand.

Project and workspace knowledge plus the customer's code and components are the main context sources, and Lovable does not describe reading instruction files from the repository or from outside sources. Design systems are Lovable projects that export reusable components, colors, fonts and styling rules, which other projects connect to and inherit, with immediate propagation, an order of precedence across several connected systems, and no versioning. Cross project referencing and about ninety integrations supply more material for each request.

Sourcedocs.lovable.dev features/knowledge, design systems FAQ and knowledge context-sources FAQread 2026-08-31

Each job keeps its chat, code and build state across sessions, so a builder can close the workspace and come back, and the agent reads the whole conversation on every turn. Workflow state persists in Temporal, so an interrupted run resumes where it left off, and a job paused at zero credits picks up again once the balance is topped up. Less carries between jobs.

A fork condenses the history into a summary the builder can edit, early details can fade after repeated compaction, and subagents start fresh on every turn. What the agent knows about a builder or team in a new job is whatever sits in the code, the forked summary or the files attached to chat.

Sourcehelp.emergent.sh/checkpoints-undo-anythingread 2026-10-09

Projects are durable objects with a history page recording changes, drafts keep unfinished work, and project chat persists. A Knowledge feature holds project configuration, and cross project referencing lets one project draw on another. Build mode explores the codebase for context on each task instead of carrying learning between tasks, and skills apply reusable instructions the customer writes, which the agent does not update.

Sourcedocs.lovable.dev projects/history, drafts, projects/chat, knowledge, cross-project-referencing, agent-mode and skills pagesread 2026-08-31

Plan mode, switched on in the composer, returns a plan card with two buttons, Request changes and Looks good, let's build it, and nothing is built until the builder approves.

Build mode, the default, starts as soon as a prompt is sent, Plan mode is unavailable in Brainstorm and E-3 sessions, and in autonomous runs a feature called Auto-HITL answers the agent's own questions with sensible defaults so the run never pauses.

Spending and release controls sit beside the plan step: a maximum credit cap per prompt that asks before going over, a budget per session, cancel from the chat menu, and a live app that changes only when someone publishes it again.

Sourcehelp.emergent.sh/talk-it-throughread 2026-10-09

Plan mode investigates the project and writes a plan the user reviews, edits and approves before any code is written, and Lovable says Plan mode never modifies code. It is one of three modes the user picks, and Build mode applies changes directly, so the approval sits in an optional mode, not in the build path. Project monitoring findings are fixed only when the user asks. Workspace admin controls, integration admin controls, groups and project visibility settings limit who can do what.

Sourcedocs.lovable.dev plan-mode and project-monitoring pagesread 2026-09-29

Projects have four roles. Owners control billing, plan and deletion, Admins manage settings, members, the database and domains, Members chat with the agent and publish, and Viewers, on Enterprise only, see the app and its history.

Business adds single sign on through SAML or OpenID Connect and role based access control, Enterprise adds user groups and workspace wide two factor enforcement, and anyone can review and revoke active sessions. Emergent holds ISO 27001:2022 and SOC 2 Type I, with GDPR alongside them in its trust center, and its DPA sets out technical measures, breach notice within 72 hours and audit reports on written request. Secrets are encrypted at rest and data in transit, and customer personal data is kept out of model training under the DPA.

Sourcehelp.emergent.sh/team-roles-permissions-collaborationread 2026-10-09

Platform controls include a trust center, SAML single sign on, SCIM provisioning, two factor authentication, workspace identity and identity reuse, groups and people access controls, integration admin controls, project visibility settings and Enterprise audit logs.

Enterprise materials describe centralized identity, granular access controls and security oversight across the workspace. Business tier has a data opt out setting, and secrets and build secrets are kept separate from generated code.

Security scanning of the generated app is separate, through a security center, security insights, sensitive data scanning and Aikido and Wiz integrations.

Sourcedocs.lovable.dev trust-center, saml-sso, business/sso, business/scim, two-factor-authentication, workspace-identity, groups, people, admin-controls, business/data-opt-out and secrets pagesread 2026-08-31

While an app builds, the workspace shows the agent's activity live: each tool call with the arguments passed and the result returned, subagent logs nested under the main agent that expand to show their own calls, the step count for the turn and the credits being spent.

A checkpoint is saved after every agent turn, publish history keeps up to three earlier production images tagged with a timestamp, and Account Settings breaks credit use down by agent runs, publishes and Universal Key calls. Enterprise adds audit logs and credit usage reports with an analytics dashboard. How long the Enterprise audit log keeps entries is unclear.

Sourcehelp.emergent.sh/custom-agentsread 2026-10-09

Enterprise audit logs record actions taken by workspace members and which client each came from (Web, Desktop, iOS or Android), filterable by client or by member, with earlier entries marked Unknown. Dedicated pages cover project monitoring, logs, project usage, analytics and security insights. Build mode shows tasks as work proceeds, and project history records changes to a project. Audit logs are listed among Enterprise workspace capabilities, alongside security oversight across the workspace.

Sourcedocs.lovable.dev audit-logs, project-monitoring, logs, project-usage, analytics and security-insights pages, changelog and lovable-for-enterpriseread 2026-08-31

Emergent runs as a hosted service, and customer data is processed and stored in the United States, the EU and India under its DPA. Builders choose the hosting region of a published app themselves, US or EU, in the Resources tab of Manage Publishing, with the EU priced higher. App databases run on MongoDB Atlas in the United States unless moved.

Enterprise deploys apps into the customer's own cloud through a VPC setup and supports a self hosted database, and any published app can move to the customer's own MongoDB by a manual runbook. The build platform and its subprocessors stay where they are whatever region an app uses, and EU only hosting for all data goes through a request to the privacy team.

Sourcehelp.emergent.sh/where-your-data-is-storedread 2026-10-09

A default hosting region is set in Settings, under Security and compliance, Privacy and security, choosing Americas, Europe or Asia Pacific. On Business and Enterprise workspaces, admins can require a default region for every new project, after which members cannot choose a different one, and existing projects keep their original region.

Country regions including Germany, Japan and United States East are available on Enterprise by request, and Enterprise materials list regional code hosting. Lovable Cloud hosts apps with custom, verified and transferable domains, and two way GitHub sync and external deployment guidance let the app be hosted elsewhere.

Sourcedocs.lovable.dev privacy-and-security-settings, cloud, hosting, custom-domain, github and external-deployment-hosting pages, lovable-for-enterpriseread 2026-08-31

New jobs start from four app types, Full Stack App, Mobile App, Landing Page and Brainstorm, each on its own stack template (React with FastAPI and MongoDB, Next.js, Python only, or Expo for mobile), and from a choice of three build agents, E-1, E-2 and E-3, which are levels of one builder.

Integrations with a playbook package a tested setup recipe for each supported service, and the build page offers example prompts for websites, mobile apps, dashboards and SaaS tools. On Pro, builders make their own custom agents in a four step wizard covering the system prompt, tools and subagents. There is no gallery of finished apps or ready made agents to clone.

Sourcehelp.emergent.sh/how-apps-work-here-mental-modelread 2026-10-09

Business tier includes design templates, alongside a managed registry, a remix path for starting from an existing project, a prompting library, skills with reusable instructions, and design systems supplying customer components. Video tutorials and an idea to app guide cover getting started. There is no catalog of finished apps published by Lovable.

Sourcedocs.lovable.dev business/design-templates, managed-registry, projects/remix, prompting-library, skills and design-systems pagesread 2026-08-31

Two choices shape a build. The agent dropdown sets the workflow, and a separate model selector picks the LLM that powers it, offered again when a fork opens, so a builder can move to another model when a provider slows down. Pro adds Ultra thinking and Maxx mode, a deeper reasoning toggle that costs significantly more credits.

Model providers in the data path include Anthropic, OpenAI, Google Gemini, xAI and Groq. The Universal LLM Key, which reaches 44 or more models from seven providers on Emergent credits or the customer's own provider keys, serves the apps being built rather than the builder.

Sourcehelp.emergent.sh/understanding-models-e1-e2-e3-maxxread 2026-10-09

The builder has no model selection, model picker, bring your own key or provider setting, including in advanced settings, workspace admin settings and account settings. The model related integrations, Fireworks, Replicate, Perplexity and Gemini Enterprise, and an AI feature among the Cloud backend pages give model access to the app being built, not a choice over the model that powers Lovable.

Sourcedocs.lovable.dev sitemap inventory, advanced-settings, workspace-admin-settings, lovable-account-settings and features/ai pagesread 2026-08-31

Emergent also works as an MCP server for clients such as Claude Desktop or Cursor, with example tools that create an app from a prompt, publish a workspace and fetch build or runtime logs, and personal access tokens with scoped permissions reach an Emergent API. The server's address and full tool list are not given alongside those examples, so how much of the platform outside code can drive is unclear. On paid plans the Universal LLM Key also works as a LiteLLM compatible proxy for calling models from scripts and CI, restricted by IP, and code leaves through Save to GitHub.

Sourcehelp.emergent.sh/mcps-connectorsread 2026-10-09

Lovable has its own API and MCP server. Agent integrations turn a published Lovable app into an MCP server that ChatGPT, Claude and other assistants can use, with configurable tools, sign in, permissions and access. Custom MCP servers, MCP registries, a create connector path and an any API route cover other services. Two way Git sync with GitHub and GitLab, including self managed and dedicated GitLab, exports the full codebase, and desktop, mobile and Slack surfaces extend access to the platform.

Sourcedocs.lovable.dev lovable-api, lovable-mcp-server, agent-integrations, custom-mcp, mcp-registries, create-connector, any-api and git-sync-overview pagesread 2026-08-31

Testing sits in the agent's own toolset. A testing subagent, called through a run_tests tool or when a builder asks for it, writes unit, integration and end to end tests for the app, runs them and reports coverage, and when a test fails the agent fixes the code and runs the tests again.

E-2 adds a workflow that proves the services it builds actually work together, a Codex review subagent lints and scans pull requests for security and style, and testing runs include visual regression scans.

Builders can ask for specific checks, such as the checkout flow end to end, results show in chat with what failed and why, and mobile apps get TestFlight and APK test builds on paid plans.

Sourcehelp.emergent.sh/debugging-testing-with-the-agentread 2026-10-09

Browser testing has the platform use the customer's app in a real browser running in a virtual environment, clicking buttons, filling forms, navigating pages and checking real user behavior with screenshots across screen sizes. It returns a verdict.

A Details view shows the steps taken and summarizes what worked and what did not, and the pattern is reproduce, fix, then verify. Where test and live environments are turned on, it runs against the project preview in the test environment, so the check happens before the change reaches anyone. The check is Lovable's own, run against the customer's app before release.

Sourcedocs.lovable.dev browser-testing page and test-and-live-environments documentationread 2026-08-31

Agents can carry out tasks in a hosted web browser run by Browserbase, seeing and typing on pages, including ones the user is signed into, and content viewed or entered there is part of the data the platform processes. Firecrawl fetches web pages as a separate agent tool, and web search costs a small credit fee per query. Inside the app builder, the browser work Emergent describes is the preview server screenshotting the app under construction for the agent to check, so whether the builder drives the hosted browser on outside sites is unclear.

Sourceapp.emergent.sh/privacy-policyread 2026-10-09

Browser testing and the preview toolbar run and display the app the agent has built, which checks the agent's own output, not third party software. Firecrawl and Apify integrations retrieve web content over HTTP, which is scraping, not computer use. All outside actions run through connectors, the any API route, custom MCP servers or MCP registries, all programmatic interfaces. There is no browser navigation, form filling, screen control or computer use.

Sourcedocs.lovable.dev browser-testing, preview-toolbar, projects/preview, firecrawl and apify pages plus sitemap inventoryread 2026-08-31