Open-source AI automation platform that converts 280+ workflow integrations into MCP servers for LLMs, with no-code builders and TypeScript extensibility.
Activepieces is an open-source automation platform designed to be the foundation for both human-driven no-code workflows and AI agent toolchains. Built as a Zapier alternative, it goes further by automatically exposing every integration as a Model Context Protocol (MCP) server, so LLMs like Claude, Cursor, or Windsurf can directly call Gmail, Slack, Notion, HubSpot, and 280+ other services through standardized tool protocols without any extra configuration.
The platform is built around a TypeScript pieces framework where every integration is an npm package that can be developed locally with hot reloading, contributed to the community registry, and automatically versioned and published to npmjs.com. Around 60% of all pieces are community-contributed, creating a growing, self-sustaining ecosystem of integrations that grow the MCP toolkit alongside the workflow library.
Activepieces runs on a multi-process architecture where the API server, execution engine, and workers are separated. User code executes inside Linux kernel-namespaced sandboxes via the isolate binary, giving OS-level isolation rather than just V8 sandboxing. Redis handles job queuing and distributed locking for multi-instance deployments, and PostgreSQL stores flow definitions, run history, and connection credentials.
For enterprise teams, Activepieces offers SAML 2.0 SSO, SCIM provisioning, granular role-based access control, audit logs, and a managed cloud option with SOC 2 and GDPR compliance. The enterprise features layer on top of the MIT-licensed community edition using a cleanly separated packages/ee directory, allowing teams to self-host the community edition with full source access while optionally purchasing enterprise capabilities.
Architecture
Activepieces uses a clean layered monorepo where API server, execution engine, worker, and UI live in separate packages tied together by a shared TypeScript types library. The execution flow is fully decoupled: the API server receives trigger events and enqueues jobs through Redis-backed queues, workers pick them up and dispatch to sandboxed engine processes via WebSocket, and the engine evaluates the flow graph step by step using a strategy pattern where each action type (code, loop, branch, piece) has a dedicated executor. This separation ensures that user-supplied code cannot affect the API server. Enterprise features layer cleanly on top of the open-source core through a matched module pattern in a separate packages/ee directory, keeping edition-specific behavior isolated without polluting core logic.
Tech Stack
The backend is a Fastify-based Node.js API server built and run with Bun for performance. PostgreSQL serves as the primary data store via TypeORM with a full migration system and CI-enforced schema validation. Redis handles both job queuing via BullMQ and distributed locking for safe multi-instance deployments. Piece execution runs inside Linux kernel-namespaced sandboxes using the isolate binary, providing OS-level process isolation beyond what V8 isolates offer. The frontend is a React application using React Query and Radix UI primitives. The MCP server implementation uses the official @modelcontextprotocol/sdk, and AI integrations are handled through the Vercel AI SDK with unified adapters for OpenAI, Anthropic, Google, Amazon Bedrock, Azure, and xAI. Build orchestration uses Turborepo.
Code Quality
The codebase maintains Vitest-based unit and integration test suites across multiple packages — shared utilities, API, worker, and web — alongside Playwright for end-to-end scenarios. Test files demonstrate realistic, detailed fixture data and cover complex flow branching and dual-authentication patterns for thorough coverage. TypeScript is applied strictly throughout, with @activepieces/shared providing typed contracts between services and a custom ActivepiecesError hierarchy with explicit error codes replacing generic exception throwing. ESLint and Prettier enforce consistent style. The extensive community pieces directory shows some variability since contributions come from hundreds of developers, but the Piece class framework enforces interface compliance. Core packages demonstrate high engineering discipline; community pieces vary proportionally with contributor experience.
What Makes It Unique The defining innovation is the automatic dual-purpose of every piece: any integration built for workflow automation simultaneously becomes an MCP server, making the entire library of 280+ integrations available to LLMs through standardized tool protocols without any additional work. The MCP server builder exposes meta-tools that let AI agents programmatically construct, validate, and publish automation workflows — meaning an LLM can build and deploy a workflow autonomously. The use of Linux kernel namespaces (isolate binary) for code sandbox isolation is more rigorous than typical V8-only sandboxing found in competing tools. The clean dual-edition architecture (MIT community + proprietary enterprise) within a single TypeScript codebase with shared types allows the community to audit and contribute to core logic while the commercial tier adds governance features transparently.
Activepieces uses a split licensing model: all core automation code outside the packages/ee and packages/server/api/src/app/ee directories is released under the MIT license, meaning you can freely use, modify, distribute, and build commercial products with the community edition. The enterprise features — including SAML SSO, SCIM provisioning, audit logs, advanced RBAC, white-labeling, and managed platform controls — are released under a proprietary Commercial License that requires an Activepieces Enterprise subscription to use in production. For most self-hosting scenarios involving small to mid-size teams without enterprise SSO or compliance requirements, the MIT-licensed community edition covers all core automation and AI agent functionality.
Running Activepieces yourself requires a non-trivial infrastructure footprint. The standard deployment uses Docker Compose with PostgreSQL, Redis, and multiple application containers (API server, worker, engine). You are responsible for provisioning these services, managing database migrations, handling backups, scaling workers horizontally for high throughput, and monitoring for execution failures. The Helm chart provides a Kubernetes deployment path for teams already operating container infrastructure, but setting up piece sandboxing properly — particularly the isolate binary with kernel namespace support — requires a Linux host with appropriate capabilities. This is not a one-click deployment; expect setup time and ongoing operational ownership.
Compared to the Activepieces cloud offering, self-hosters miss out on managed upgrades, built-in high availability, SLA guarantees, and first-party support channels. The cloud tier also provides pre-configured AI credit management, platform-level analytics, and a shared OAuth app registry that eliminates the need to create your own OAuth clients for services like Google or Microsoft. Enterprise license holders gain access to dedicated support, but the self-hosted path fundamentally means your team absorbs the operational burden that the cloud product handles for you. Teams with mature DevOps capabilities and strict data residency requirements will find self-hosting viable; teams without those capabilities should weigh the operational overhead honestly against the cloud option.
Automation · Productivity · AI Assistants
Build, deploy, and run autonomous AI agents that automate complex multi-step workflows using a visual block-based graph editor.
Productivity · Project Management · Collaboration
The open-source AI workspace that puts your data, your rules — with local LLMs, CRDT collaboration, and full self-hosting built in.
Devops · Automation · Security
A cloud-native reverse proxy and load balancer that auto-configures itself from Docker, Kubernetes, and other orchestrators — zero manual routing required.