[opensourcedex]

liteflow is a free, open source ai development platforms project written in Java and released under Apache-2.0. It has 3,860 GitHub stars, 526 forks and 64 open issues, and was last pushed 2 months ago. On this registry it ranks #102 of 139 tracked projects in AI Development Platforms, with 5 head-to-head comparisons available.

What is liteflow?

LiteFlow is an Apache-2.0 licensed, Java-based component rule engine that drives complex business orchestration from a small DSL rule file — and, since v2.16.0, treats an AI Agent as a first-class citizen that can be orchestrated shoulder to shoulder with ordinary business nodes.

What it is

LiteFlow is a component-based rule and flow engine for the JVM. Every piece of logic becomes a component with a unified implementation, and a DSL rule file arranges those components into the order the business needs. The rule file can be written in XML, JSON or YML, whichever a team prefers, and the entry barrier is deliberately low: the README claims the rules syntax takes about five minutes to learn and that reading a rule file shows how the logic works. Synchronous and asynchronous steps can be mixed freely, rules can be nested through simple expressions, and any ordinary class can be turned into a component declaratively. It runs on any Java framework, not only Spring, with full support for Spring Boot 2.X, 3.X and 4.X, and JDK versions from JDK8 through JDK25 — virtual threads are supported on JDK21 and above.

The problem it solves is orchestration sprawl: business flows that would otherwise be scattered across imperative service calls, conditional glue and hard-wired sequencing are instead expressed in rule text that is separate from the code and readable on its own. The flow engine replaces that hand-written wiring, and, unlike a classic rule engine, it focuses on arranging components rather than only evaluating conditions. Because rules can be loaded natively from a structured database, Nacos, Etcd, Zookeeper, Apollo or Redis — or from anywhere else through an extension interface — a change to the flow no longer requires a change to the deployment. Hot refresh swaps rules instantly without restarting the application, and the README states that high concurrency does not produce errors while rules are being refreshed. Context isolation protects the data of concurrent executions.

Key capabilities

  • DSL rule files support XML, JSON and YML as three equivalent ways to write the same orchestration.
  • Rules load natively from a structured database, Nacos, Etcd, Zookeeper, Apollo and Redis, with an extension interface for any other storage.
  • Hot refresh applies rule changes without restarting the application and without errors under high concurrency.
  • Script nodes support Groovy, Java, Kotlin, JavaScript, QLExpress, Python, Lua and Aviator, and scripts can call Java methods, reference any instance and make RPC calls.
  • AI Agent orchestration wraps a full ReAct Agent into a standard LiteFlow component.
  • Component retry is configurable per component, including which exceptions trigger it, and nested rules build multi-level layouts from simple expressions.
  • Step information reports how a link performed, how much time each component took and which errors were raised.

Who uses it and how

  • Teams running complex componentized business flows on Spring Boot 2.X, 3.X or 4.X, or on other Java frameworks, use the rule file as the readable map of the flow.
  • Organizations that keep rules in Nacos, Apollo, Zookeeper, Etcd, Redis or a database use that store as the deployment channel, so flow changes ship without an application restart.
  • Projects on JDK21 and above can use virtual threads inside the engine, and the same engine still serves projects pinned to JDK8.
  • The README states that the framework has run stably on the core systems of major companies and has become an established presence among Chinese open-source rule engines, with a large community-driven user base that files issues and suggestions.
  • Since v2.16.0, teams can place an AI Agent inside a business rule next to existing nodes rather than calling it from a separate orchestration layer.

Getting started

The README points to the official website at https://liteflow.cc and the documentation at https://liteflow.cc/pages/5816c5/ as the entry point for installation and usage, and the project is community-driven with joining instructions on the official site. The README excerpt does not publish Maven coordinates, a Docker image or a compose file, so the documentation is the place to confirm the exact dependency and version.

How it compares

No list of paid products that this project replaces is provided in the facts, and no comparable tool is named either, so LiteFlow stands alone in this registry. Its distinguishing trait within these facts is the combination of a component rule engine with native AI Agent orchestration from v2.16.0, offered under Apache-2.0.

When to use it — and when not to

A self-hoster must operate the rule store they choose — a structured database, Nacos, Etcd, Zookeeper, Apollo or Redis — since that store is what makes hot refresh work, and the README documents no bundled server or hosted tier. It also assumes a JVM stack; teams outside Java get nothing from it, and anyone expecting ready-made package coordinates, a container image or a compose file in the README will have to read the documentation instead. The licence is clear, the project has been open-sourced since 2020 and the last push was recent, but the README excerpt is thin on operational limits and on non-functional guarantees, and the repository carries 64 open issues, so the community and the documentation are the real source of truth.

project readme (upstream, from github) — read inline

中文

Your star is my motivation to keep going. If you like LiteFlow, please help me with a star in the upper right corner.

Overview

LiteFlow is a powerful, modern rules engine framework that combines the best of orchestration and rules engines. It can be used in the field of complex componentized business orchestration. DSL rules drive the whole complex business, and can achieve smooth refresh hot deployment, supporting the embedding of multiple scripting language rules. Help the system become more silky and flexible.

LiteFlow was officially open-sourced in 2020 and has since become an indispensable presence in the field of open-source rule engines in China. What's more, the most crucial aspect is that LiteFlow is an open-source project that continues to iterate at a high speed.

Starting from v2.16.0, LiteFlow even turns an AI Agent into a first-class citizen that can be orchestrated directly into your rules, standing shoulder to shoulder with your existing business nodes.

LiteFlow is a community-driven project with a strong emphasis on its large and active user community. We welcome you to raise any issues or suggestions you may have within the community.

You can find out how to join the community on the official website!

Website url: Click here to access the official website

Documents url: Click here to enter the documentation to learn

Feature

  • Component definition unified: All logic is a component, for all logic to provide a unified component implementation, small size, large energy.
  • Rules lightweight: based on the rules file to arrange the process, learning the rules entry only takes 5 minutes, a read both understand.
  • Rule diversification: rules support XML, JSON, YML three rule file writing methods, which you like to use.
  • Arbitrary arrangement: Synchronous asynchronous mixing, no matter how complex the logic process, using LiteFlow rules, are easy to do, see the rules file to see how the logic works.
  • Rules can be loaded from anywhere: The framework natively supports storing rules in a structured database, Nacos, Etcd, Zookeeper, Apollo and Redis. It also provides an extension interface that allows you to store rules anywhere.
  • Elegant hot refresh mechanism: Rule changes, instant change of application rules without restarting your application. High concurrency does not cause any errors in executing rules due to refreshing rules.
  • Wide support: LiteFlow works regardless of whether your project is built on Spring Boot, Spring, or any other Java framework.
  • JDK support: From JDK8 to JDK25. Don't worry about JDK versions. Virtual threads are supported on JDK21 and above.
  • Full Spring Boot support: Supports Spring Boot 2.X, 3.X, and now the latest Spring Boot 4.X.
  • Scripting language support: You can define script language nodes that support Groovy, Java, Kotlin, JavaScript, QLExpress, Python, Lua and Aviator. More script languages will be supported in the future.
  • Scripts fully connected with Java: All scripting languages can call Java methods, reference any instance, and even make RPC calls inside scripts.
  • AI Agent orchestration: Wraps a full ReAct Agent into a standard LiteFlow component, so AI can be orchestrated directly into your business rules.
  • Rule nesting support: You can use simple expressions to create multiple nested complex logic layouts if you want.
  • Component retry support: Components can support retry, and each component can customize the retry configuration and specify exceptions.
  • Context isolation mechanism: Reliable context isolation mechanism, you do not have to worry about high concurrency data flow.
  • Declarative component support: You can make any of your classes become components in seconds.
  • Detailed step information: How your link performs, how much time each component takes, what errors are reported at a glance.
  • Stable and reliable: has been iterating for more than 2 years, running stably on the core systems of major companies.
  • Excellent performance: the framework itself consumes little extra performance, depending on the efficiency of your component execution.
  • Built-in simple monitoring: Built-in a command line monitoring framework, you can know the running time ranking of each component.

What scenarios apply

LiteFlow is a choreographed rules engine that is best at decoupling your systems. If you have a complex system with bloated code, the LiteFlow framework is a great solution.

LiteFlow uses regular expressions to drive the engine that you define. Have you ever thought about how to write multithreaded process choreography like the following?

These processes can be easily solved with LiteFlow! The framework has a very low threshold to learn the expression language, but it can accomplish extremely high complexity of the choreography.

LiteFlow has an extremely detailed and easy-to-understand documentation， it can help you solve more than 95% of your problems when using the framework.

LiteFlow has 2000 test cases and more. Complete documentation and comprehensive test case coverage guarantee the stability of LiteFlow framework!

Looking forward to your use！

AI Agent Orchestration (New in v2.16.0)

Starting from v2.16.0, LiteFlow ships its own AI Agent module, liteflow-react-agent.

It is not a simple "LLM component". Instead, it wraps a full ReAct (Reasoning + Acting) Agent into a standard LiteFlow component — one component is one Agent. You only declare a component and implement a few simple methods; talking to LLM providers, multi-turn conversation memory, and the Skills system are all handled for you by the module.

Once an Agent becomes a LiteFlow component, it automatically inherits the full orchestration power of LiteFlow. You write rules exactly the way you always have — except one of the nodes is now a thinking AI:

// Sequential orchestration, the AI node naturally sits between business nodes
THEN(prepare, deepseekAgent, recordReply);

// Let two different LLMs analyze the same question in parallel
WHEN(deepseekAgent, qwenAgent);

// Route to different Agents based on a condition
IF(isMath, mathAgent, deepseekAgent);

// Multi-Agent collaboration: parallel analysis + aggregated decision
THEN(prepare, WHEN(analyzerAgent, riskAgent), summaryAgent, notify);

None of THEN, WHEN, IF, SWITCH or FOR here is newly invented for AI — they are the same orchestration operators LiteFlow has used for years. If you can orchestrate LiteFlow, you can orchestrate AI.

The module connects to mainstream LLM platforms — OpenAI, Claude, Gemini, DeepSeek, Qwen (DashScope), Kimi, GLM and more — and provides multi-turn conversation memory, the Skills system, workspace file tools, streaming output, and so on. Switching models is basically a one-line change to model().

Note: The AI Agent module is built on agentscope-java and requires JDK 21+ at runtime. See the official documentation for the full usage guide.

DISCORD LINK

Discord Link: https://discord.gg/MpdBSBnFTu

WECHAT OFFICIAL ACCOUNT

Since the community group is over 200 people, you need to be invited to join the group. Follow the WECHAT OFFICIAL ACCOUNT and click Personal WeChat to add me, I can invite you into the group

official-wx

Open source is not easy, please sponsor LiteFlow if you support it

Frequently asked questions

Is liteflow free to use?

liteflow is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does liteflow do?

Lightweight, fast, stable, programmable component-based rule engine — where AI Agents orchestrate just like ordinary components. Uniquely designed DSL: componen

What is liteflow written in?

liteflow is primarily written in Java. Its source is publicly available at https://github.com/dromara/liteflow, and it has 3,860 GitHub stars.