Bolt.new vs Dust

Converts natural language prompts into executable full-stack web applications by invoking an AI agent that generates React/Next.js frontend code, Node.js backend logic, and database schemas. The agent runs code in-browser via WebContainers to validate syntax and functionality before deployment, iterating on the generated code based on execution feedback. Token consumption scales with project complexity (larger codebases consume more tokens per iteration), and the agent supports design system imports from Figma and GitHub to accelerate UI generation.

Unique: Executes generated code in-browser via WebContainers (in-browser Node.js sandbox) rather than sending code to cloud-only execution, enabling real-time validation and iteration without external deployment overhead. Integrates design system imports (Figma, GitHub) directly into code generation pipeline, reducing manual UI scaffolding.

vs alternatives: Faster than Vercel v0 or GitHub Copilot for full-stack generation because it validates code execution in-browser before deployment and supports integrated design system imports; more accessible than traditional frameworks because it requires zero local setup (no Node.js, npm, or build tools needed).

Runs generated Node.js code and React applications directly in the browser using WebContainers, a sandboxed JavaScript runtime that emulates a Linux environment. The agent automatically executes generated code to validate syntax, test functionality, and detect errors before user review. WebContainers provide filesystem isolation, process sandboxing, and network restrictions, preventing malicious code from accessing the host system. Test results feed back into the agent's iteration loop to refactor and fix errors.

Unique: Uses StackBlitz's proprietary WebContainers technology to run a full Linux-like environment in the browser, eliminating the need for cloud deployment or local Node.js setup. Integrates execution feedback directly into the agent's iteration loop, enabling autonomous error detection and refactoring without user intervention.

vs alternatives: Faster than cloud-based code execution (AWS Lambda, Google Cloud Run) because it runs locally in the browser with zero network latency; more secure than eval()-based execution because WebContainers provide true process isolation and filesystem sandboxing.

Provides two interaction modes: Plan Mode (where the agent outlines a development strategy before implementation) and Discussion Mode (where the agent and user iterate on requirements and design before code generation). Plan Mode enables users to review and approve the agent's approach before code is generated, reducing wasted token consumption on incorrect implementations. Discussion Mode optimizes token efficiency by clarifying requirements upfront. The specific differences between modes and their impact on token consumption are undocumented.

Unique: Separates planning from implementation into distinct interaction modes, allowing users to validate the agent's approach and clarify requirements before token-consuming code generation. Enables token-efficient workflows by deferring code generation until requirements are confirmed.

vs alternatives: More efficient than direct code generation because it allows requirement clarification upfront, reducing wasted tokens on incorrect implementations; more transparent than single-mode agents because users can review and approve the development strategy before execution.

Generates React Native mobile applications using Expo framework and integrates with Expo services for building, testing, and deploying iOS and Android apps. The agent generates Expo-compatible code with native module support and can configure Expo build services for over-the-air updates and app store deployment. Mobile app generation follows the same natural language prompt interface as web apps, abstracting platform-specific complexity.

Unique: Extends full-stack web generation to mobile platforms using Expo, allowing users to generate cross-platform apps (web + iOS + Android) from a single natural language prompt. Integrates Expo build services for native app compilation and distribution without requiring local development environment setup.

vs alternatives: More comprehensive than React Native CLI or Expo CLI because it generates complete mobile apps from prompts without manual setup; more accessible than native development because it abstracts platform-specific complexity and uses familiar React patterns.

Indexes the project filesystem and codebase to provide context-aware code generation and completion. The agent analyzes existing code structure, imports, dependencies, and patterns to generate code that integrates seamlessly with the existing project. Token consumption scales with project size because the entire codebase is indexed and included in the context window. The indexing mechanism and compression strategy are undocumented.

Unique: Analyzes and indexes the entire project codebase to provide context-aware code generation that respects existing patterns, structure, and dependencies. Enables seamless integration of generated code with existing projects without manual refactoring or conflict resolution.

vs alternatives: More context-aware than GitHub Copilot because it indexes the entire project rather than just the current file; more efficient than manual code review because it automatically detects and respects existing patterns and conventions.

Provides 'Plan Mode' and 'Discussion Mode' features that enable iterative refinement of applications through conversation. Users can discuss design decisions, ask the agent to plan features before implementation, and refine requirements through dialogue. The agent maintains conversation context and can adjust implementation based on feedback without losing project state.

Unique: Separates planning from implementation, allowing users to discuss and refine requirements before code generation — this reduces wasted effort on incorrect implementations and enables collaborative design.

vs alternatives: More collaborative than one-shot code generators because it enables iterative dialogue and refinement, treating the agent as a design partner rather than just a code generator.

Stores generated and edited Bolt projects in Bolt Cloud infrastructure, providing persistent storage across browser sessions and device access. Projects are associated with user accounts and can be accessed from any browser. Storage limits are 10MB (free tier) and 100MB (Pro tier). Projects can be shared publicly or privately (private sharing requires Pro tier). No documented export format or data portability mechanism; projects are locked into Bolt's infrastructure.

Unique: Provides transparent cloud storage for Bolt projects without requiring users to manage local files or external storage services, but creates vendor lock-in by not documenting export formats or data portability mechanisms

vs alternatives: Simpler than GitHub (no version control overhead) and more integrated than Google Drive (project-specific storage), but less portable due to lack of documented export format

Provides a 'Plan' mode that allows users to discuss and refine application requirements before code generation begins, and a 'Discussion' mode for iterative refinement after generation. The agent can break down complex requirements, ask clarifying questions, and validate understanding before committing to code generation. This reduces iteration cycles by ensuring requirements are clear before implementation.

Unique: Separates planning and discussion from code generation, allowing the agent to validate and refine requirements before committing to implementation. This reduces wasted token consumption on incorrect implementations and improves alignment between user intent and generated code.

vs alternatives: More deliberate than immediate code generation because it validates requirements first; more collaborative than one-shot generation because it enables iterative refinement; more efficient than trial-and-error because it reduces implementation cycles.

Enables non-technical users to construct multi-step AI agents through a drag-and-drop interface without writing code. The builder abstracts tool orchestration, model selection, and data flow into visual blocks that chain together semantic search, API calls, and LLM reasoning steps. Agents are deployed immediately to a cloud runtime without compilation or deployment infrastructure.

Unique: Combines visual workflow composition with multi-tool orchestration in a single no-code interface, allowing non-technical users to define agent behavior through block-based logic rather than prompt engineering or code. Agents execute immediately in Dust's cloud runtime without requiring deployment infrastructure.

vs alternatives: Faster to prototype than Copilot or ChatGPT plugins for non-technical teams because it provides visual agent composition without requiring API integration code or prompt management.

Indexes documents from 10+ connected data sources (Google Drive, Notion, Confluence, GitHub, Slack, Zendesk, etc.) into a searchable knowledge base using semantic embeddings. Agents query this index with natural language to retrieve relevant context before generating responses, enabling RAG-style information retrieval without manual document management. Search results are ranked by semantic relevance and can be filtered by source or metadata.

Unique: Automatically indexes documents from 10+ heterogeneous sources (Slack, Notion, Confluence, GitHub, Google Drive, Zendesk, etc.) into a unified semantic search index without requiring manual ETL or document preprocessing. Agents can query this index with natural language to retrieve context before generation.

vs alternatives: Broader connector ecosystem than Verba or LlamaIndex alone — integrates with enterprise platforms (Confluence, Zendesk, Salesforce) out-of-the-box rather than requiring custom connectors.

Provides dashboards and metrics for monitoring agent performance (success rate, execution time, tool usage) and tracking costs (API calls, token consumption, model usage). Metrics are aggregated by agent, time period, and data source. Cost tracking shows spending by model provider and helps identify optimization opportunities.

Unique: Provides integrated performance monitoring and cost tracking dashboards showing agent success rates, execution times, tool usage, and API costs aggregated by agent and time period. Helps teams identify optimization opportunities and allocate costs.

vs alternatives: More integrated than external analytics tools because cost and performance metrics are captured at the agent level without requiring custom instrumentation or log parsing.

Enables agents to navigate websites, fill forms, extract data from web pages, and interact with web applications programmatically. Agents can click buttons, type text, read page content, and follow links to complete multi-step web tasks. Web navigation is sandboxed and does not require agents to manage browser state or handle JavaScript rendering.

Unique: Provides agents with web navigation capabilities to interact with websites, fill forms, and extract data without requiring custom browser automation code. Web navigation is sandboxed and handles JavaScript rendering transparently.

vs alternatives: Simpler than Selenium or Playwright for non-technical users because web navigation is abstracted as a tool rather than requiring custom browser automation code.

Enables agents to analyze structured data and query databases using natural language without requiring SQL knowledge. Agents can read data from Google Sheets, databases, and other structured sources, perform aggregations and transformations, and generate reports. Natural language is translated to queries internally, abstracting SQL complexity.

Unique: Enables agents to query structured data and generate reports using natural language without requiring SQL knowledge. Agents translate natural language questions to queries internally, abstracting database complexity.

vs alternatives: More accessible than traditional BI tools because agents understand natural language questions without requiring users to learn SQL or BI tool syntax.

Dust enables teams to create and manage multiple versions of agents, test changes in staging environments, and deploy updates to production with rollback capabilities. Users can compare agent versions, track changes, and revert to previous versions if needed. The platform supports gradual rollouts (e.g., deploying to 10% of users first) and A/B testing different agent configurations.

Unique: Dust provides agent versioning and deployment management, enabling teams to test changes safely and rollback if needed. The platform supports gradual rollouts and A/B testing, reducing risk when deploying agent updates.

vs alternatives: Safer than deploying agent changes directly to production because Dust enables staging, testing, and gradual rollouts; teams can validate changes before exposing them to all users.

Abstracts LLM provider differences by supporting GPT-5, Claude, Gemini, and Mistral models through a unified interface. Agents can be configured to use different models for different tasks, and the platform handles API key management, request routing, and error handling across providers. Model selection is configurable per agent or per step within an agent workflow.

Unique: Provides unified API abstraction across 4+ LLM providers (OpenAI, Anthropic, Google, Mistral) with per-agent model selection, eliminating the need to manage separate API clients or rewrite agent logic when switching models. Handles authentication and request routing transparently.

vs alternatives: Simpler than LiteLLM or LangChain for non-technical users because model selection is a UI dropdown rather than code configuration, while still supporting multi-provider orchestration.

Provides pre-built connectors to 10+ enterprise platforms (Slack, Google Drive, Notion, Confluence, GitHub, Zendesk, Salesforce, Chrome Extension) that handle authentication, data fetching, and schema mapping without custom code. Connectors support both read operations (querying data for agent context) and write operations (creating tickets, posting messages). Generic connectors (API, Google Sheets, Zapier) enable integration with any HTTP endpoint or workflow platform.

Unique: Provides native, pre-built connectors to 10+ enterprise platforms (Slack, Notion, Confluence, Zendesk, Salesforce, GitHub) with read/write capabilities, eliminating the need for custom API integration code. Generic connectors (API, Sheets, Zapier) extend coverage to any HTTP endpoint.

vs alternatives: Broader native connector coverage than Make or Zapier for enterprise platforms because connectors are purpose-built for agent use cases (e.g., semantic search across Confluence, ticket creation in Zendesk) rather than generic workflow automation.