# LiteFlow

> A powerful, open-source Java rules engine framework for complex componentized business orchestration with DSL-driven rules, hot deployment, and AI Agent support.

LiteFlow is an open-source Java rules engine framework under the Apache License 2.0, maintained by the Dromara community. It combines orchestration and rules engine capabilities, enabling developers to decouple complex business logic into reusable components driven by a lightweight DSL. First open-sourced in 2020, the project has been iterating at high speed and, as of v2.16.0, treats AI Agents as first-class orchestration citizens.

## What It Is

LiteFlow is a component-based rule engine and process orchestration framework for Java applications. Rather than hardcoding complex business flows, developers define components (each encapsulating a unit of logic) and then describe how those components connect using LiteFlow's DSL — supporting sequential (`THEN`), parallel (`WHEN`), conditional (`IF`), switch (`SWITCH`), and loop (`FOR`) operators. The result is a system where business logic is readable, testable, and hot-reloadable without application restarts.

## Core Orchestration Capabilities

LiteFlow's DSL supports a wide range of flow patterns out of the box:

- **Synchronous and asynchronous mixing** — parallel branches run concurrently; sequential branches run in order
- **Rule nesting** — simple expressions compose into arbitrarily complex nested logic layouts
- **Component retry** — per-component retry configuration with customizable exception targeting
- **Context isolation** — a reliable isolation mechanism prevents data leakage across concurrent executions
- **Declarative components** — any Java class can become a component with minimal annotation

Rules can be stored in XML, JSON, or YAML and loaded from structured databases, Nacos, Etcd, Zookeeper, Apollo, Redis, or any custom source via an extension interface.

## AI Agent Orchestration (v2.16.0)

Starting from v2.16.0, LiteFlow ships `liteflow-react-agent`, a module that wraps a full **ReAct (Reasoning + Acting) Agent** into a standard LiteFlow component. Key characteristics of this module:

- One component equals one Agent — developers declare a component and implement a few methods; LLM communication, multi-turn conversation memory, and the Skills system are handled by the module
- Connects to mainstream LLM platforms: OpenAI, Claude, Gemini, DeepSeek, Qwen (DashScope), Kimi, GLM, and more
- Switching models requires a one-line change to `model()`
- Supports streaming output and workspace file tools
- Built on agentscope-java; requires JDK 21+ at runtime

Because an Agent is just another LiteFlow component, all existing orchestration operators apply unchanged — AI nodes sit naturally alongside business nodes in `THEN`, `WHEN`, `IF`, `SWITCH`, and `FOR` expressions.

## Scripting Language and Platform Support

LiteFlow supports embedding script-language nodes directly in rules, covering Groovy, Java, Kotlin, JavaScript, QLExpress, Python, Lua, and Aviator. All scripting languages can call Java methods, reference any instance, and make RPC calls inside scripts. On the platform side:

- **JDK support**: JDK 8 through JDK 25; virtual threads supported on JDK 21+
- **Spring Boot**: 2.X, 3.X, and 4.X
- **Framework agnostic**: works with Spring, Spring Boot, or any other Java framework

## Update: v2.16.0 and AI Agent Module

The most recent major milestone is v2.16.0, which introduced the `liteflow-react-agent` AI Agent module. This release marks a deliberate product-direction shift: LiteFlow positions itself not just as a rules/orchestration engine but as a framework where AI reasoning and traditional business logic coexist in the same rule graph. The repository was last pushed in June 2026 and last updated in July 2026, indicating active ongoing development. The project carries 3,789 GitHub stars and 517 forks as reported by the repository metadata.

## Why It Matters for Java Teams

LiteFlow addresses a common pain point in large Java codebases: business logic that has grown tangled and hard to change. By externalizing flow definitions into hot-reloadable DSL rules, teams can modify orchestration without redeployment. The framework's built-in command-line monitoring shows per-component execution time rankings, and its 2,000+ test cases provide stability guarantees. The community-driven model under the Dromara organization means issues and suggestions are handled through an active public channel.

## Features
- Component-based rule engine with unified component definition
- DSL-driven orchestration supporting XML, JSON, and YAML rule files
- Synchronous and asynchronous (parallel) flow mixing
- Hot deployment with elegant rule refresh without application restart
- AI Agent orchestration via liteflow-react-agent (ReAct Agent)
- Multi-turn conversation memory and Skills system for AI Agents
- Connects to OpenAI, Claude, Gemini, DeepSeek, Qwen, Kimi, GLM and more
- Scripting language nodes: Groovy, Java, Kotlin, JavaScript, QLExpress, Python, Lua, Aviator
- Rule storage in databases, Nacos, Etcd, Zookeeper, Apollo, Redis, or custom sources
- Rule nesting for complex logic layouts
- Per-component retry with customizable exception targeting
- Context isolation mechanism for high-concurrency safety
- Declarative component support
- JDK 8–25 support; virtual threads on JDK 21+
- Spring Boot 2.X, 3.X, and 4.X support
- Built-in command-line monitoring with per-component execution time ranking
- 2000+ test cases for stability assurance

## Integrations
Spring Boot, Spring Framework, Nacos, Etcd, Zookeeper, Apollo, Redis, OpenAI, Claude, Gemini, DeepSeek, Qwen (DashScope), Kimi, GLM, Groovy, Kotlin, JavaScript, Python, Lua, Aviator, QLExpress, agentscope-java

## Platforms
API, DEVELOPER_SDK, CLI

## Pricing
Open Source

## Version
2.16.0

## Links
- Website: https://github.com/dromara/liteflow
- Documentation: https://liteflow.cc/pages/5816c5/
- Repository: https://github.com/dromara/liteflow
- EveryDev.ai: https://www.everydev.ai/tools/liteflow