ByteChef

ByteChef is an open-source platform that brings AI agent orchestration and workflow automation together under one roof, eliminating the need to run separate tools for each. It provides a visual drag-and-drop editor for building multi-step workflows and AI agents, backed by a durable execution engine that persists state in PostgreSQL and scales horizontally via message broker queues.

At its core, ByteChef’s fromAi() system makes every connector action dynamically bindable by an AI agent at runtime, turning all 180+ built-in connectors into native agent tools without any adapter glue code. The platform supports 14 LLM providers through Spring AI, integrates bidirectionally with the Model Context Protocol (MCP), and runs polyglot code in Java, JavaScript, Python, and Ruby via GraalVM — all within the same workflow definition.

ByteChef is designed for organizations that need full data ownership and self-hosted deployment without sacrificing enterprise capabilities. It ships with built-in knowledge bases and RAG pipelines backed by 15+ vector stores, 12 guardrail types, human-in-the-loop approval flows, and a unified audit trail correlating agent decisions with workflow runs. The CE edition is Apache 2.0 licensed; enterprise features like Git-native workflows, AI Copilot, SSO, and embedded iPaaS live in a separate EE directory under the ByteChef Enterprise License.

What You Get

• Visual Workflow Editor - Drag-and-drop canvas for designing multi-step workflows with 14 flow control primitives including condition, loop, each, parallel, branch, fork-join, and sub-workflows.
• First-Class AI Agents - A dedicated AI Agent component runs the full ReAct loop (model → tool selection → execution → observation → next step) with streaming output, structured responses, and configurable memory backends.
• 180+ Connectors as Agent Tools - Every built-in connector action is automatically available as an AI agent tool via the fromAi() annotation, covering CRM, messaging, cloud storage, databases, finance, e-commerce, and AI/ML services.
• 14 LLM Providers via Spring AI - Connect to OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Vertex Gemini, Mistral, Groq, DeepSeek, Ollama, Nvidia, Hugging Face, Perplexity, and OpenRouter from a unified interface.
• Bidirectional MCP Integration - Consume any external MCP server as a tool source for agents, and expose any workflow as an MCP tool to clients like Claude Desktop or Cursor, with API-key authentication.
• Knowledge Bases and RAG Pipelines - Native document ingestion with chunking and 15+ vector store backends including pgvector, Pinecone, Qdrant, Weaviate, Milvus, and Redis for retrieval-augmented generation.
• 12 Guardrail Types - Built-in safety controls for PII detection, jailbreak prevention, NSFW filtering, topical alignment, secret key scanning, URL filtering, and custom regex/rule-based policies.
• Polyglot Code Execution - Write inline code in Java, JavaScript, Python, or Ruby on GraalVM within any workflow step, replacing external function execution environments.
• Durable Atlas Execution Engine - Workflow state is persisted to PostgreSQL with pluggable queue backends (Redis, RabbitMQ, Kafka, JMS, AMQP, AWS SQS) for horizontal scaling and fault-tolerant execution.
• Human-in-the-Loop Approvals - Pause any workflow on a human approval step, route to Slack or email, and resume automatically on response — with all decisions captured in the unified audit trail.

Common Use Cases

• AI-assisted customer support triage - An operations team builds an agent that reads incoming support emails, queries a knowledge base for matching solutions, creates Jira tickets with structured data, and drafts reply suggestions — all without leaving the workflow canvas.
• Automating multi-system data pipelines - A data engineering team connects PostgreSQL, Google Sheets, and Slack to run nightly reconciliation workflows that pull records, transform them with inline Python, flag anomalies, and post summaries to a channel.
• Embedding AI automation in a SaaS product - A B2B platform uses ByteChef’s embedded iPaaS (EE) to let their customers configure native integrations between their CRM and communication tools, surfacing ByteChef’s workflow engine directly inside the product UI.
• Multi-agent coordination with human checkpoints - A compliance team runs a coordinator agent that delegates document analysis to specialist sub-agents, pauses for human review on sensitive findings, and resumes the workflow only after an auditor approves via an approval link.
• Exposing internal workflows as MCP tools - A platform team wraps internal approval, provisioning, and notification workflows as MCP tools so that AI coding assistants like Cursor can invoke them directly during development without leaving the editor.

Under The Hood

Architecture ByteChef is structured as a deeply layered modular monolith with three distinct tiers that enforce clean separation without requiring microservices deployment. The Atlas layer at the foundation manages raw job lifecycle through an event-driven model using Spring ApplicationEvents — coordinators dispatch tasks, workers execute them, and all state is durably persisted to PostgreSQL. Above Atlas, the Platform layer introduces domain concepts like components, connections, knowledge bases, MCP servers, and AI tools, each split into strict API and implementation modules that enforce interface boundaries. The Automation layer adds user-facing concepts like projects, workflows, triggers, and scheduling. Task dispatch is handled through a composable TaskDispatcher chain supporting fourteen flow control primitives including branch, condition, each, loop, parallel, fork-join, and subflow. The EE directory adds enterprise capabilities without contaminating the open-source core, and the Atlas queue abstraction allows the same codebase to scale horizontally via Redis, Kafka, RabbitMQ, or SQS message brokers.

Tech Stack The backend runs Java 21 on Spring Boot 3.x with Spring Data JDBC against PostgreSQL for workflow state persistence. Spring AI provides a unified abstraction over fourteen LLM providers including OpenAI, Anthropic, AWS Bedrock, Vertex Gemini, Mistral, Groq, and Ollama. In-workflow polyglot code execution uses GraalVM to run Java, JavaScript, Python, and Ruby without external function execution services. The frontend is React with TypeScript, Vite, and Tailwind CSS; documentation runs on Next.js with MDX. Builds use Gradle with Checkstyle, PMD, SpotBugs, and FindSecBugs for static analysis. CI runs on GitHub Actions, deployment targets Docker Compose for single-node and Kubernetes with Helm charts for production clusters. The Model Context Protocol SDK enables bidirectional MCP tool exchange between ByteChef and external AI tooling ecosystems.

Code Quality The codebase has comprehensive test coverage with over sixteen hundred JUnit test files, combining Mockito-based unit tests with Testcontainers integration tests that spin up real PostgreSQL instances. Static analysis is enforced at build time through Checkstyle, PMD, SpotBugs, and FindSecBugs, with FindSecBugs specifically targeting security vulnerabilities in dependency code. Error handling is explicit and typed: a custom ExecutionError domain hierarchy carries structured error context through the coordinator event system, and REST controllers return standardized problem-detail responses. The consistent API/impl module split across every domain enforces that implementations are swappable, enabling the in-memory repository variants used in unit tests. Null safety is documented through JSpecify annotations and deliberate @SuppressFBWarnings suppressions, and every public API module carries extensive Javadoc.

What Makes It Unique ByteChef’s most architecturally distinctive feature is the fromAi() annotation system, which makes every connector action and its properties dynamically bindable by an AI agent at inference time — turning all hundred-plus connectors into native agent tools without any adapter layer. The bidirectional MCP integration goes further: ByteChef can simultaneously consume external MCP servers as agent tool sources and expose its own workflows as MCP tools to Claude Desktop, Cursor, or Windsurf with API-key authentication. The unified audit log that correlates agent reasoning steps, tool invocations, workflow task executions, and human approval decisions in a single correlated trail is rare in open-source automation platforms. The Atlas durable execution engine with pluggable queue backends provides enterprise-grade fault tolerance that most open-source workflow tools do not offer, and the GraalVM polyglot runtime embedded in workflow steps eliminates the operational overhead of managing separate function execution environments.

Self-Hosting

ByteChef uses a dual-license open core model. Everything outside the /ee/ directories is released under the Apache License 2.0, which permits commercial use, modification, distribution, and private use with no copyleft obligations. The /ee/ directories — covering microservices deployment, embedded iPaaS, AI Copilot, Git-native workflow management, multi-environment promotion, SSO/SAML/OIDC, SCIM, advanced RBAC, and the AI Gateway — are governed by the ByteChef Enterprise License. That license permits modification and testing without a subscription but requires a paid Enterprise agreement for production use. Self-hosters should read the LICENSE file carefully before enabling any EE features in a production environment.

Running ByteChef yourself is a meaningful operational commitment. The minimal setup requires Docker and PostgreSQL, and the provided docker-compose.yml gets a single node running quickly. For production workloads, you are responsible for PostgreSQL high availability, backups, schema migrations across upgrades, and tuning the message broker (Redis, RabbitMQ, Kafka, or SQS) used for distributed task queuing. The Atlas execution engine is designed to survive restarts by replaying from the PostgreSQL job log, but you must ensure that the database itself is durable. Horizontal scaling requires deploying separate coordinator and worker instances and wiring them through a shared queue, which adds infrastructure complexity. Kubernetes Helm charts are provided, but operating them at scale demands platform engineering expertise.

Compared to a managed integration platform, self-hosting ByteChef means you own the entire operational surface: version upgrades, security patching, connector library updates, and outage response. The community edition provides Discord support and GitHub issues; enterprise customers get SLA-backed support channels. Managed SaaS alternatives typically handle connector versioning, infrastructure scaling, and compliance certifications automatically, while ByteChef’s self-hosted approach gives you complete data residency control and the ability to deploy in air-gapped or regulated environments where external SaaS tools are not permitted.