Blazen: An Event-Driven Orchestration System for Agent Workflows

Blazen is an event-driven workflow orchestration system designed specifically for agent workflows, while also being applicable to various general workflow scenarios, providing flexible node orchestration and state management capabilities.

As AI applications evolve from single-model calls to multi-agent collaboration, effectively orchestrating complex workflows has become a core challenge for developers. The Blazen project was born to address this issue—it is an event-driven workflow orchestration system designed specifically for agentic workflows, while also being flexibly applicable to various general workflow scenarios. Unlike traditional static workflow engines, Blazen adopts an event-driven architectural paradigm, allowing workflows to dynamically adjust paths based on runtime conditions during execution, which provides a solid foundation for building adaptive and intelligent AI applications.

Blazen's core design philosophy is to treat workflows as a series of event flow processes. Each node can both consume and produce events, and the system achieves loosely coupled communication between components through an Event Bus. This design brings several significant advantages:

• Dynamic Routing: Workflow paths can be dynamically determined based on event content at runtime
• Observability: Each event is a clear record of system state changes, facilitating tracking and debugging
• Scalability: New nodes can be seamlessly integrated into existing event streams without modifying other components
• Fault Tolerance: Event persistence mechanisms ensure the system can recover from failures

Unlike general-purpose workflow engines, Blazen has been specifically optimized for the characteristics of agent workflows:

• Asynchronous Interaction: Agents often need to wait for external API responses or user input; Blazen natively supports asynchronous event processing
• State Management: Provides mechanisms for persistence and sharing of agent context
• Tool Calling: Built-in tool registration and calling framework to simplify LLM function calling processes
• Human-Machine Collaboration: Supports inserting manual review nodes into automated processes

Nodes in Blazen are the basic building blocks of workflows. Each node defines:

• Input Event Type: The type of event the node listens to
• Processing Logic: The business logic executed by the node after receiving an event
• Output Event: The new event triggered after processing is completed

Nodes are implicitly connected via event types, forming a directed graph structure. This declarative design allows developers to focus on business logic without worrying about underlying connection details.

Workflows in Blazen are defined in a declarative manner, supporting:

• Sequential Execution: Nodes are executed in a predefined order
• Parallel Branches: Multiple nodes process different event streams simultaneously
• Conditional Routing: Dynamically select execution paths based on event content
• Loop Iteration: Supports conditional-based loop execution modes

Blazen's execution engine is responsible for scheduling and executing workflows:

• Event Queue: Ensures events are processed in order and supports priority scheduling
• Concurrency Control: Configurable concurrency level to prevent resource overload
• Timeout Management: Sets timeout limits for node execution to prevent infinite waiting
• Retry Mechanism: Failed nodes can be automatically retried according to policies

In complex AI applications, multiple specialized agents often need to collaborate. For example:

• Research Assistant: One agent handles information retrieval, another handles content summarization, and a third handles quality review
• Code Assistant: Requirement analysis agent, code generation agent, and testing agent collaborate in sequence
• Customer Service System: Intent recognition agent, knowledge retrieval agent, and response generation agent work in a pipeline

Blazen's event-driven architecture is naturally suited for such scenarios, where each agent acts as an independent node and passes intermediate results through events.