Lovable vs Replit Agent (2026)

The catalog runs to roughly ninety individually documented integrations spanning CRM, data warehouses, ecommerce, payments, accounting, communications, HR, security scanning, analytics, storage and CMS, which is breadth across classes rather than depth in one. The design detail worth carrying is the three connection types. A connector can be attached as an app connector, a chat connector, or an app user connector where each end user of the published app connects their own account. That last one means a built app can act on behalf of its individual users rather than through one shared service credential, a materially better security posture than a single shared token. Not every connector supports every type, and each catalog page states which it supports. Beyond the catalog, an any-API route and a create-connector path cover anything unlisted, and custom MCP servers plus MCP registries make the tool surface open-ended.

Integrations span classes, and one design choice stands out: connectors activate automatically based on the prompt rather than being wired in advance, so the customer describes the outcome and the relevant integration engages itself. Breadth reaches data warehouses through dedicated BigQuery, Databricks, Snowflake and Microsoft Fabric connectors, plus the working examples in Replit's own use cases that reach HubSpot, Slack, Gmail, calendar, Linear, GitHub, Ashby, Notion, Drive and Shopify. Mobile adds Clerk for auth and RevenueCat for payments. MCP makes the set open-ended, with a server directory and custom servers for anything unlisted. Governance is unusually mature: connector management is documented across Core, Pro and Enterprise with centralized admin controls, scoped access and audit tracking, so an organization decides which tools Agent may reach rather than each builder deciding alone. Replit's own MCP server, which lets outside clients call Replit, counts toward extensibility.

Build mode, previously called Agent mode, takes ownership of execution end to end: it understands intent, explores the codebase for context, applies changes across files, and resolves issues that appear during development, with visible tasks showing progress. Paired with Plan mode for decisions, that is a two-phase multi-step system rather than single-shot generation. Subagents are documented as their own feature, so work delegates rather than running in one context, and cross-project referencing lets one project draw on another, so composition works between projects. Skills carry reusable instructions, and code mode and an editor expose the generated files for hand editing. Drafts and project history give the iteration loop somewhere to stand.

Parallel tasks are the distinguishing feature: Agent breaks work into tasks that run in the background and are applied back to a main version, and Replit documents building several features at once, with guidance on delegating safely and slicing work small. That is concurrent execution against a protected main line, which is close to how engineering teams work. Around it, Plan and Build modes separate deciding from doing, Conversations and Projects are distinct surfaces with guidance on when to move work from one to the other, and Routines add scheduled recurring runs that return into a thread. Artifacts let one project hold several related outputs, and teammates can each run their own Agent task on the same project. Replit also builds agents and automations that run on its own cloud with Slack, Telegram and scheduled triggers, which is orchestration the customer ships as well as orchestration the customer uses.

Project monitoring has Lovable 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 surfacing findings to fix in the project chat. That is a scheduled wake of the builder agent. 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.

Routines schedule Replit itself. A Routine is a scheduled run attached to a Conversation that can use connected tools, create tasks in connected services and send messages, with results returning to the same thread; Replit's own example is reviewing Slack each morning and returning the day's priorities. That is scheduling applied to the agent rather than to the app it built. The implementation is concrete: intervals of an hour or more, five active Routines on Core and ten on Pro, a per-run budget checked after each step, a run-now action, run history, and a documented rule that a due Routine waits rather than queuing a second run if work is already going. The stated limit is candid too: Routines cannot schedule publishing. Channels are wide as well, with Conversations, the prompt box, Voice Mode for spoken prompts, a mobile app and Slack context.

Knowledge is persistent text instructions, not a document store. Workspace knowledge holds shared rules across every project such as coding standards, preferred libraries and naming conventions; project knowledge adds application purpose, database schema, architecture decisions and domain terminology. It is always included in context, which Lovable contrasts with Skills, which load on demand. Workspace knowledge is described as a text field. The limit is stated in Lovable's own FAQ: project and workspace knowledge plus the code and components are the primary context sources, and the reference material does not describe reading instruction files from the repository or external sources. There is no ingestion of customer documents and no retrieval over a corpus; this is closer to a durable system prompt than to grounding on a knowledge base. Design systems are a second structure but ground style rather than knowledge: any project can be designated a design system and others connect to inherit its components and styles, with immediate propagation and precedence ordering when several are connected, though Lovable notes they are not versioned.

Replit gives Agent several kinds of context but no maintained retrieval index over the customer's documents. Per-request context and file uploads supply material for a single job. Custom Instructions hold workspace-wide conventions across Projects and sessions. Enterprise design systems, held in the project as a DESIGN.md, and Agent Skills with supporting material count toward templates, and project memory, retrieved when relevant, counts toward memory. The BigQuery, Databricks, Snowflake and Microsoft Fabric warehouse connectors point Agent at the customer's data, but as the data source for the apps it builds, which counts toward integrations. What is left for this axis is per-request context, which is Partial.

Lovable's state plainly persists: projects are durable objects with their own history, drafts persist unfinished work, project chat persists, and a Knowledge feature holds configuration that outlives any single conversation. Cross-project referencing makes state addressable between projects. What holds it at Partial is that none of it accumulates. Build mode explores the codebase for context at the start of each task rather than carrying learning forward, and skills are authored by the customer and stay as written; nothing is documented as the agent updating its own instructions after a correction. Durable state, yes; memory that compounds, no.

Replit has a dedicated Memories feature, described as retaining useful context across conversations and projects, which is this axis stated almost word for word. Replit separates it from two neighbors: Custom Instructions carry workspace-wide guidance across Projects and sessions, and Skills package reusable instructions, and a published page explains when to use each of the three. Conversations are durable objects that Routines attach to and return results into, so scheduled work builds up in a thread over time.

Plan mode investigates the project and writes a plan the user reviews, edits and approves before any code is written, and Lovable states Plan mode never modifies code. It is one of three modes the user picks, and Build mode implements changes directly, so the approval sits in an optional mode rather than 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 constrain who can do what.

The task system is a review-and-apply gate: Agent breaks work into tasks that run in the background, and each is reviewed before it is applied back to the main version. The person reviewing inspects finished work against a protected main line rather than approving an intention, which is what makes parallel building safe; Replit's guidance on building in parallel is about delegating safely and applying changes without surprises. Three further layers sit around it. Plan and Build modes separate deciding from doing. Checkpoints record state so work can be rolled back, and Replit's guidance on working with Agent names reviewing, testing and using checkpoints as core practice. Spend is a guardrail too, with usage limits, budgets, per-user spend limits for workspaces, and a per-run budget on every Routine that is checked after each step. Administrative oversight sits above the builder through roles, custom groups on Enterprise, connector scoped access and organization-wide privacy settings.

The controls documented here govern Lovable itself, not only the app it builds: a trust center, SAML single sign-on, SCIM provisioning, two-factor authentication, workspace identity with identity reuse across workspaces, groups and people-level access control, integration admin controls, and Enterprise audit logs. Enterprise materials describe centralized identity, granular access controls and workspace-wide security oversight as the point of the plan. A data opt-out is documented as a Business capability, which matters because the training-data question is the one enterprise buyers ask first about an AI code generator, and it is answered as a setting rather than a policy statement. Secrets and build secrets are handled separately so credentials do not sit in generated code. Security scanning of the generated application, through a security center, security insights, sensitive-data scanning, scheduled Deep scans and Aikido and Wiz integrations, secures the output and counts toward testing. SOC 2 and ISO 27001 are consistent with the published trust center, but the certificates themselves have not been read.

Both halves are covered. On attestation, SOC 2 Type II with a documented information security program. On controls, the depth is unusual and so is the self-serve access: SAML SSO is configured from workspace settings with an in-product wizard that provisions the connection once the customer pastes their identity-provider values, and the Enterprise plan itself can be bought online without a sales call, so a buyer can reach these controls in minutes rather than through a contract. The rest: SCIM provisioning with group-to-workspace mapping, roles across Admin, Member, Guest and Viewer with Enterprise-only custom groups, a split between account admins and workspace admins, audit logs with SIEM integration, organization-wide privacy and source-control settings, and connector management with centralized admin control, scoped access and audit tracking. Private deployment is a delivery property and counts toward deployment rather than here.

Lovable audit-logs the platform itself, recording actions taken by workspace members. A change shipped on 24 August 2026 added client attribution, so each entry records whether an action came from Web, Desktop, iOS or Android, and the log filters by client or by member; entries before that date read as Unknown. That sits alongside project monitoring, logs, project usage and analytics, and security insights, so both the platform and the built app are observable. Audit logs are an Enterprise capability. What is still absent is a trace of the agent's own reasoning within a build: visible tasks show progress but not why a choice was made.

Audit logs feed the customer's SIEM. Exporting security-relevant actions into the customer's own security tooling means the record leaves Replit in a form the customer controls and can correlate with everything else, which makes it an audit trail a security team can operate rather than a log to look at. Three more layers sit around it. An Enterprise analytics dashboard reports activity, resource usage, published apps and costs, so spend is attributable per team. Connector management carries audit tracking alongside scoped access, so tool use is traceable and not just permitted. At the work level the task system shows what Agent did as reviewable tasks, Routines keep run history, and checkpoints record state. This is the platform being observed, not only the app it builds: Replit records its own activity and its members'.

This is real residency, not disclosure. A default hosting region is chosen from Americas, Europe or Asia Pacific; on Business and Enterprise workspaces an admin can set a required region for every new project, and members then cannot choose otherwise, which is the enforcement half; and country-specific regions including Germany, Japan and United States East are available on Enterprise by request. Enterprise materials describe this as regional code hosting. One operational detail will catch people: the setting applies only to new projects, and existing projects keep the region they were created in, so a workspace that adopts a residency policy late does not relocate what it has already built. Beyond region choice the output is unconstrained: Lovable Cloud hosts with custom, verified and transferable domains, two-way GitHub sync gives the customer the codebase, and external deployment and hosting-ownership guidance covers taking the app elsewhere entirely.

Replit builds, tests, publishes and runs the app in one place, so the runtime is part of the product rather than a hand-off. Publishing types match workload shape: autoscale for request-driven apps, scheduled for time-based work, static for sites, and reserved always-on capacity. Mobile publishing is documented end to end for both stores, covering Apple Developer enrollment, App Store Connect upload and signing, TestFlight beta distribution, Play Console upload and internal testing tracks. Custom domains can be bought and connected in-product. Enterprise adds private deployments, and Replit is listed on the GCP and Azure marketplaces, with a Microsoft Azure partnership pairing Replit with Azure infrastructure. The gap: no customer-selectable hosting region is documented, so residency is weaker than the deployment surface.

Design templates are documented as a Business capability, alongside a managed registry, a remix path for forking an existing project as a starting point, a prompting library, skills carrying reusable instructions, and design systems supplying the customer's own components. What Lovable ships ready-made is a set of design templates and a registry; the substantial reusable assets are ones the customer or the community builds. Remix is the closest to adopting a packaged asset, since forking a working project is adopting rather than assembling, but it depends on there being projects to fork.

Replit ships adoptable assets by several routes, and one of them works at organization scale: Enterprise custom templates standardize how a whole organization builds with Agent, and Enterprise design systems configure Agent with the company's component library and tokens so every artifact follows the design language. Below that, featured templates can be remixed into a project, a documented quickstart builds and publishes from a template, the Design library panel supplies starter templates plus Mobbin-curated inspiration and lets a customer reuse their own creations, and Agent Skills package specialized knowledge that can be installed or used to start a project. The public gallery shows what people are shipping, with view and use counts per template, which is a browsable catalog.

Lovable exposes no model selection anywhere in a documentation inventory of roughly two hundred pages, and an inventory that complete makes the silence meaningful. The near-misses do not count. Fireworks, Replicate, Perplexity and Gemini Enterprise appear as integrations, and an AI feature page sits among the Cloud backend pages; those give the application being built access to models, which is the opposite of what this axis measures. This is a product position rather than an oversight: Lovable is opinionated about the builder and open about what the built app can reach. A buyer with a model-approval policy will care.

Replit offers both automatic routing and manual selection. Intelligent model routing picks a model per task, and a documented model selector lets the customer override it and also set an Effort level, which separates which model runs from how hard it should think. Replit Design documents exploring the same design with different models, on the grounds that each brings its own sensibility, so model choice becomes a creative tool as well as a cost lever. Agent Modes across Free, Power and Max set capability and spend. Manual model selection depends on mode and plan, so some customers get routing only.

Both directions are documented. Outbound, Lovable itself is callable from outside through a documented Lovable API and a Lovable MCP server. A third route is unusual: agent integrations turn the customer's published app into an MCP server for ChatGPT, Claude and other assistants, with configurable tools, sign-in and permissions. Lovable's framing is clear: people use an app by clicking buttons and moving through screens, an assistant cannot click, so it needs a list of actions instead. That extends the output rather than the platform, so it supports rather than carries the grade. Also documented: custom MCP servers, MCP registries, a create-connector path, an any-API route, and two-way GitHub and GitLab sync so the codebase leaves without lock-in.

Replit publishes its own MCP server, documented as connectable by compatible MCP clients, so the platform is callable from outside by any assistant that speaks the protocol. The inbound direction is documented separately and counts toward integrations: Agent connects to external tools through pre-listed MCP servers or custom ones, with four more added to the directory in a single July release. Agent Skills package reusable instructions with supporting material, and a separate page explains how skills differ from MCP servers. Underneath sits older extensibility: Replit is a full cloud IDE across more than fifty languages with source control, so the codebase is editable and portable by hand. Import paths bring projects in from other builders and from GitHub, and Replit documents importing from other vibe-coding platforms specifically.

Browser testing has the platform interact with the customer's application in a real browser running in a virtual environment, clicking buttons, filling forms, navigating pages and verifying behavior with screenshots across different screen sizes. It returns a verdict: a Details view shows the steps taken and summarizes what worked and what did not, and the documented pattern is reproduce, fix, then verify. Where test and live environments are enabled it runs against the project preview in the test environment, so the evaluation happens before the change reaches anyone. A criterion applied by Lovable's mechanism to the customer's artifact ahead of release is Full.

Agent tests the application it built in a real browser, writes a report and fixes what it finds before handing the work back. The application under test belongs to the customer and the testing mechanism is Replit's, which is why this reaches Full. Other gates sit in the release path: real-device mobile testing through Expo Go and the TestFlight and Play Console internal testing tracks, the task system's review before work is applied to the main version, and checkpoints for rollback. A security checklist covers securing the apps Agent generates.

Browser testing is not computer use. Exercising the application just generated inside a browser to check that it works is verification of Lovable's own output; this axis counts only an agent operating third-party software that offers no programmatic interface. The preview toolbar and preview pages are the same thing viewed by a person. The Firecrawl and Apify integrations retrieve web content over HTTP, which is scraping rather than computer use. Everything Lovable's agent touches externally, it touches through a documented connector, an API or an MCP server. Nothing in a two-hundred-page documentation inventory describes navigating or operating an external application.

Agent can operate a real browser, but through a partner. The Browserbase connector runs managed headless browsers for fetch, search and full session automation, for when Agent needs to load a real page, run JavaScript or work with a site that blocks plain HTTP requests. Replit does not ship a browser of its own, and no first-party navigation, form filling or computer-use capability is documented, which keeps this at Partial. Agent also tests the apps it builds in a browser, but that is checking its own output rather than operating other software, and it counts toward testing.