Bubble Lab is an open-core workflow engine that powers the Bubble Lab platform, allowing teams to automate operational tasks using AI agents (Pearl) directly within Slack. It solves the problem of context switching by enabling users to describe complex workflows in natural language and execute them across tools like Gmail, Notion, Jira, and Postgres — all without leaving Slack. Built for developers and operations teams, it combines AI-driven task execution with type-safe TypeScript workflows and real-time observability.
The engine is built in TypeScript and runs on Node.js, with a modular architecture based on ‘Bubbles’ (reusable integration nodes). It supports local development via a CLI, self-hosting, and exportable workflows. The open-core version includes the runtime, CLI tooling, execution tracing, and integration primitives — enabling full control over deployment, customization, and extension without vendor lock-in.
What You Get
- TypeScript-based Workflow Engine - Build workflows as TypeScript classes with
BubbleFlow base class, using .action() to chain integrations like RedditScrapeTool or AIAgentBubble with full type safety and IDE support.
- Bubbles (Integration Primitives) - Reusable, modular nodes (e.g.,
RedditScrapeTool, AIAgentBubble, NotionUpdateNode) that encapsulate API calls, AI processing, and data transformations with built-in error handling and logging.
- Slack-Native AI Operator (Pearl) - AI assistant embedded in Slack that interprets natural language prompts to trigger and manage workflows, enabling non-technical users to automate tasks without leaving their chat interface.
- Local Workflow Studio - Run and edit workflows locally via
pnpm run dev on http://localhost:3000 with real-time execution feedback, logging, and debugging capabilities.
- CLI Tooling (
create-bubblelab-app) - Scaffold new projects with pre-configured templates (e.g., reddit-scraper, email summarizer) including dependencies, sample flows, and dev server setup in one command.
- Execution Observability - Built-in metrics for token usage, duration, memory peak, and step-by-step tracing of each ‘Bubble’ execution, visible in terminal output and logs for debugging and optimization.
Common Use Cases
- Daily Slack-based briefings - A business operations manager uses Pearl to automatically read unread emails, summarize them, and post a daily update in Slack with meeting agendas and action items — eliminating manual review.
- Automated lead pipeline management - A sales team triggers a workflow that scrapes LinkedIn leads, enriches them with company data via API, and adds them to Notion CRM — all initiated by a Slack command.
- Investor deal tracking automation - An investor asks Pearl to pull recent event data, sync deal details with internal databases, and generate investor memos — reducing manual data entry by 80%.
- Non-technical team automating healthcare workflows - A healthcare startup’s operations team uses Bubble Lab to build multi-agent workflows that process large patient datasets and generate compliance reports — without writing code or relying on engineers.
Under The Hood
Architecture
- Modular monorepo structure with distinct apps, packages, and tools enabling independent development and deployment
- Core architecture built around the IBubble interface and its specialized implementations, enforcing a plugin-based model where each bubble encapsulates domain-specific behavior
- Dependency injection via package-level exports and workspace references, with a centralized runtime engine that resolves and executes schema-defined bubbles
- Domain-specific schemas strictly typed with Zod and shared across API, UI, and runtime layers to ensure end-to-end type consistency
- Turbo monorepo tooling enforces explicit build dependencies, ensuring changes in core components propagate reliably to dependent applications
- Next.js frontend and Hono API are decoupled from core logic via shared schemas, preserving framework-agnostic execution while enabling rich user and API experiences
Tech Stack
- Monorepo managed with pnpm and Turbo, featuring shared packages for runtime, schemas, and tooling
- Next.js and React 19 frontend with TanStack Router and React Query for state and data management
- TypeScript 5.8.3 with comprehensive ESLint and TypeScript ESLint rules for strict type safety and code quality
- Hono-based API server with Zod for runtime validation and automatic OpenAPI generation
- Dockerized deployment via Railway with isolated service definitions for API, dashboard, and landing pages
- Tailwind CSS and Monaco Editor integrated to deliver a powerful, code-rich IDE experience in Bubble Studio
Code Quality
- Extensive test coverage spanning unit, integration, and schema validation layers, emphasizing real-world data flows and edge cases
- Strong type safety enforced through Zod schemas across all layers, preventing runtime errors via proactive validation
- Clear separation of concerns with dedicated bubble types for services, tools, and workflows, each with focused test suites
- Robust error handling using structured response tuples instead of exceptions, ensuring predictable and traceable error propagation
- Consistent naming and modular design, with domain-specific components like GoogleSheetsBubble encapsulating behavior with explicit dependencies
- Strict TypeScript practices, schema-driven validation, and minimal use of @ts-expect-error demonstrate disciplined code hygiene
What Makes It Unique
- Event-driven content engine that dynamically generates ideas by parallelizing real-time scraping of news, YouTube, and Reddit—breaking from static trend analysis
- BrowserBase integration with session lifecycle management to automate credential capture, eliminating manual login steps in data extraction
- Declarative BubbleFlow framework that encodes complex AI research pipelines as reusable, schema-validated workflow templates
- Custom voice-to-text pipeline with browser-based audio processing, avoiding third-party dependencies while preserving transcription fidelity
- Template system with metadata annotations (@canBeFile) enabling context-aware parameter binding and self-documenting AI workflows
- Unified schema-driven API layer across frontend and backend, eliminating code duplication and ensuring end-to-end type safety for complex AI data structures