What is Ecotone Framework?

Ecotone is the PHP framework for durable workflows, event sourcing, Domain-Driven Design, reliable messaging, and asynchronous communication — one Composer package that adds sagas, orchestrators, aggregates, projections, outbox, retries, and CQRS to Laravel or Symfony through declarative PHP attributes. It runs on the database and broker you already operate; no separate workflow service, no replay-deterministic DSL, no engine-specific event log.

Do I need Temporal or a separate workflow engine to build durable workflows in PHP?

No. Ecotone delivers durable execution on the database and broker you already run. Sagas persist state per identifier, chained workflows survive crashes through the outbox plus async channel, saga timeouts use a #[Delayed] attribute, and Orchestrators (Enterprise) give declarative multi-step workflows. There is no separate cluster to operate, no RoadRunner or ext-grpc requirement, no replay-deterministic DSL — workflows are plain PHP classes with attributes. If you have already adopted Temporal, Ecotone still fits around it for CQRS, projections, distributed messaging, multi-tenant routing, and sagas that aren't full workflows.

Which message brokers does Ecotone work with?

RabbitMQ, Apache Kafka, Amazon SQS, Redis, and the database (DBAL outbox) are first-party — and Ecotone also integrates with Enqueue transports, Symfony Messenger transports, and Laravel Queue channels. Handler code is broker-agnostic: a single #[Asynchronous('channel')] attribute works the same across every transport. CombinedMessageChannel writes the message to the database for the outbox guarantee and dispatches execution on the broker, so outbox draining stays on the database and consumers scale horizontally on RabbitMQ / SQS / Kafka.

Can I use Ecotone with Laravel or Symfony?

Yes. Ecotone ships dedicated packages for both Laravel and Symfony that make integration seamless. After installation, Command, Event, and Query buses are available out of the box in the dependency container — and for any other framework, Ecotone Lite provides a standalone integration via PSR-11.

Do I need to rewrite my application to use Ecotone?

No. Ecotone works alongside your existing application — you adopt it incrementally for the parts where messaging, sagas, event sourcing, or distributed messaging make sense, without rewriting what already works. Ecotone sits above Symfony Messenger and Laravel Queues, using them as transports underneath rather than replacing them.

Why pick Ecotone over Spatie laravel-event-sourcing, EventSauce, or Patchlevel for event sourcing?

Ecotone provides a built-in event store on PostgreSQL or MySQL with #[EventSourcingAggregate], #[ProjectionV2] for read models (global, partitioned, or streaming), default-on gap detection so concurrent-transaction events aren't silently skipped, projection emission via EventStreamEmitter with rebuild auto-suppression, and end-to-end PII encryption across the event store, broker payloads, and structured logs. Compared to Spatie laravel-event-sourcing (Laravel-only, single-process rebuild, no gap detection), EventSauce (no subscription engine, shared-envelope dispatch), and Patchlevel event-sourcing (single-cursor per projection, encryption stops at the event-store boundary), Ecotone covers the operational axes that matter for high-volume event-sourced systems.

Does Ecotone support building systems following Domain-Driven Design?

Ecotone's vocabulary is DDD vocabulary: #[Aggregate], Repository abstraction, #[Saga] as process managers, bounded-context isolation via the Distributed Bus, and Domain Events as first-class plain PHP classes. Where each building block is fully decoupled from the framework using declarative configuration. Ecotone is the only framework that makes DDD build blocks easily composable in Message-Driven systems, to not only ensure clear business logic, but to make the system build on top of reliable architecture.

The PHP Orchestration Layer

Orchestrators with routing-slip semantics, Sagas as stateful coordinators, Distributed Bus + Service Map between PHP services, EIP primitives as attributes, multi-tenant header-routed channels — one declarative orchestration model.

Orchestration Layer — full guide Install Ecotone

Composer package · Laravel or Symfony · PostgreSQL or MySQL · RabbitMQ, Kafka, SQS, Redis, or DBAL outbox

What Ecotone provides

Capabilities relevant to orchestration layer

Sagas & Workflows

Stateful long-running processes with compensation. Handler-chaining workflows for stateless pipelines. Saga timeouts in one #[Delayed] attribute. All declarative, all attribute-driven.

Durable Workflows in Plain PHP

Crash-resistant multi-step processes on your existing database and broker. Sagas, orchestrators, chained workflows, outbox, and #[Delayed] timeouts — plain PHP attributes, no separate workflow service, no replay-deterministic DSL.

Compose Patterns Without Glue

Aggregate publishes event. Saga subscribes by attribute. Projection subscribes by attribute. Async handler subscribes by attribute. The attribute is the wiring.

Composable EIP Messaging

Pipe handlers together. Route by payload or headers. Split one message into many. Filter, enrich, transform — all as attributes, no glue code.

Multi-tenant Messaging

Tenant-isolated event streams, tenant-routed message channels, priority routing by customer status. Multi-tenancy as a topology property, not a WHERE clause.

Endpoint-ID Routing

Rename classes, move handlers, refactor namespaces — messages still route correctly. The endpoint ID is the contract; FQCN is not on the wire.

How it compares

PHP alternatives for this category

Each row names what you'd need to add to match Ecotone, and the architectural ceiling that integration cannot fix.

Temporal PHP SDK

Workflow code runs in Temporal's runtime, not yours. Cluster + RoadRunner.

Workflow code executes inside the Temporal worker (RoadRunner + `ext-grpc`), not your application's process.
Cross-service messaging goes through Temporal's internal task queues — your RabbitMQ / Kafka / SQS only enters the picture inside Activities that bridge to them.
No EIP primitives (routers, splitters, filters) as first-class; orchestration is the workflow language itself, not a separate routing layer.

Durable Workflow (formerly Laravel Workflow)

Workflow logic, not surrounding orchestration. Laravel-only.

Workflow classes extend `Workflow`, activities extend `Activity`. The workflow body is the orchestration unit.
No EIP primitive layer (routers, splitters, filters as attributes).
No distributed bus between services. No Service Map for cross-broker topology.
No multi-tenant header-routed channels. Laravel-only.

Symfony Messenger alone

A transport-level bus. No EIP, no distributed bus, no multi-tenant API.

Messenger moves messages through transports configured by DSN; YAML routing binds messages to transports.
No EIP primitives — routers, splitters, filters, enrichers must be implemented as middleware classes or stamps you wire yourself.
No distributed bus between services. No Service Map for multi-broker topology declaration.
Multi-tenant routing has no first-class API — officially single-tenant per app.

Ecotone

Process orchestration, service orchestration, and message routing on one model.

**Process orchestration**: `#[Orchestrator]`, `#[Saga]`, chained `#[InternalHandler]` workflows.
**Service-to-service orchestration**: Distributed Bus + Service Map across multiple brokers.
**Message-routing orchestration**: routers, splitters, filters, enrichers, transformers as EIP primitives on plain methods.
CQRS message buses (`CommandBus`, `EventBus`, `QueryBus`) out of the box on Laravel, Symfony, or Ecotone Lite.
Multi-tenant header-routed channels in one deployment.
No Java cluster to operate, no BPMN modeller required.
Shared retry / DLQ / idempotency / PII / OpenTelemetry middleware across the orchestrator and the handlers it dispatches into — not three separate retry stories you reconcile by hand.

Read the Orchestration Layer guide

Frequently asked questions

Haven’t found what you’re looking for? Contact us

Ecotone. It provides the same architectural tier — declaring how messages flow, which steps compose into processes, and where messages cross service boundaries — built on the same Enterprise Integration Patterns vocabulary that underpins Spring Integration, NServiceBus, MassTransit, and Wolverine. Routers, splitters, filters, enrichers, transformers are PHP attributes on plain methods; Orchestrators define multi-step workflows declaratively; Distributed Bus + Service Map route between PHP services over the brokers you already operate.

Camunda and Zeebe are mature BPMN engines and the right choice at the engine level if your organisation already operates a JVM cluster and stakeholders want BPMN diagrams. One PHP-specific factual point: no actively-maintained Camunda PHP SDK exists in 2026 — the most-discoverable community client (`tistre/camunda_php_client`) was archived in February 2025. For PHP teams that don't want to add a Java cluster and don't have a BPMN-modelling requirement, Ecotone delivers declarative orchestration as PHP attributes inside your application — Orchestrators, Sagas, Distributed Bus, EIP primitives, multi-tenant routing — on the database and broker you already operate.

Each PHP service registers #[Distributed] handlers; the Distributed Bus routes commands and events between services over the broker you've configured (RabbitMQ, Kafka, SQS, Redis). The Service Map carries the topology — which service consumes which routing keys, on which broker — so adding a service is a config change, not a code change in every caller. Multi-broker single-topology: some services on Kafka, others on RabbitMQ, all coordinated through one Service Map.

An #[Orchestrator] defines a workflow as a sequence of channel names using the routing-slip pattern — each step is a #[InternalHandler] independently testable and reusable, and the orchestrator method returns the channel list for the next steps (including dynamic step lists chosen from input data). A #[Saga] is a stateful coordinator that remembers where it is across events arriving over time. Orchestrators are for processes where you know the steps up front; Sagas are for processes that react to external events asynchronously.

Be part of the change with Ecotone

Unleash the power of Messaging in PHP
and push productivity to the higher level

Get started