StackBlitz Bolt vs Replit Agent (2026)

Eight built-in MCP connectors plus any remote MCP server, each action toggled separately, alongside first-party integrations across design, version control, hosting, payments, data, mobile publishing and authentication.

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.

A documented project lifecycle runs from prompt to published app across many files in an in-browser runtime, with Plan Mode as a separate planning phase, skills carrying reusable workflows and a Prompt Library.

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.

Work reaches Bolt through the chatbox, fed by prompts, files, designs, templates or a Lovable import, with real-time collaboration; no scheduled, webhook or event-driven trigger is documented.

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.

A design system generated from the customer's material is stored, managed and kept in sync as its sources change, alongside knowledge held at account, workspace and project scope.

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.

Projects, backups, version history, project knowledge and design systems persist, but nothing the agent learns accumulates; skills and saved prompts stay as the customer wrote them.

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 is an optional review step and connector actions, team roles and repository access can be restricted, but Build Mode applies changes with no documented approval step.

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.

SOC 2 Type 2 with a trust profile at trust.bolt.new, encryption, monitoring and annual penetration tests, plus team access management and provisioning on Teams and SSO and audit logs on Enterprise.

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.

Version history, GitHub commit sync, hosting analytics and database logs record the project, but no agent run trace or tool-call record is documented and no organization audit log appears in the documentation.

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'.

BYOK deployment runs Bolt inside the customer's own AWS or Azure tenant with full infrastructure isolation, development executes client-side in the browser, and published apps can sit on Bolt Cloud, Netlify, Expo or anywhere through GitHub export.

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.

A vendor Templates catalog of named, previewable working templates opens in Bolt with one click, alongside team templates, built-in prompts and skills.

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.

Bolt Forge lets the customer pick among open-source models from several makers on individual Pro plans, in research preview to 14 October 2026, while the Standard and Max agents choose models behind the scenes.

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.

GitHub sync with full codebase export, outbound MCP connectors and the open-source bolt.diy fork, but no API, SDK or first-party MCP server for driving Bolt itself is documented.

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.

A project security check finds and fixes security problems, with live preview, backups, branches and troubleshooting guides, but no test generation, regression suite or scoring of one build against another.

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.

Builds run in an in-browser Node runtime and the live preview shows the agent's own app; no operation of third-party software through its interface is documented.

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.