diff --git a/docs/en/intro/what-is-agentsflex.md b/docs/en/intro/what-is-agentsflex.md
new file mode 100644
index 0000000..234b6dd
--- /dev/null
+++ b/docs/en/intro/what-is-agentsflex.md
@@ -0,0 +1,94 @@
+# What is Agents-Flex?
+
+Agents-Flex is an AI application development framework developed in Java, designed to simplify AI application development. It draws inspiration from LangChain, LlamaIndex, and the author's best practices as a frontline AI application developer, providing API support across AI service providers that is portable and not limited to Java development frameworks.
+
+Agents-Flex is suitable for various scenarios, including chat, image generation, embedding models, function calling, and RAG applications, and supports both synchronous and streaming API options.
+
+
+## Comparison between Agents-Flex and other frameworks
+
+**1、More universally applicable**
+
+Compared to `Spring-AI` and `LangChain4j`, Agents-Flex is more universally applicable.
+
+> 1) For example, `Spring-AI` requires JDK version `JDK 21+` whereas Agents-Flex only needs `JDK8+`.
+> 2) `Spring-AI` requires usage within the Spring framework, whereas Agents-Flex supports integration with any framework and provides `spring-boot-starter`.
+
+**2、Simpler API design**
+
+With Agents-Flex, chat functionality can be implemented in just two lines of code.
+
+```java
+@Test
+public void testChat() {
+    OpenAILlm llm = new OpenAILlm.of("sk-rts5NF6n*******");
+    String response = llm.chat("what is your name?");
+
+    System.out.println(response);
+}
+```
+
+Function Calling also requires just a few lines of code with Agents-Flex.
+
+```java
+public class WeatherUtil {
+
+    @FunctionDef(name = "get_the_weather_info", description = "get the weather info")
+    public static String getWeatherInfo(
+        @FunctionParam(name = "city", description = "the city name")String name ) {
+        //Here, we should retrieve API information through third-party interfaces
+        return name + "weather is cloudy with overcast. ";
+    }
+
+
+    public static void main(String[] args) {
+        OpenAILlm llm = new OpenAILlm.of("sk-rts5NF6n*******");
+
+        FunctionPrompt prompt = new FunctionPrompt("What's the weather like in Beijing today?", WeatherUtil.class);
+        FunctionResultResponse response = llm.chat(prompt);
+
+        Object result = response.getFunctionResult();
+
+        System.out.println(result);
+        //"The weather in Beijing is overcast turning to cloudy. "
+    }
+}
+```
+
+**2、More Powerful Agents Orchestration**
+
+We know that a powerful AI application often requires flexible orchestration capabilities. Compared to Agents-Flex, `Spring-AI` and `LangChain4j` lack almost any orchestration capabilities.
+
+Below is a simple example code of Agents-Flex regarding Chain (execution chain) orchestration:
+
+```java
+public static void main(String[] args) {
+    SequentialChain ioChain1 = new SequentialChain();
+    ioChain1.addNode(new Agent1("agent1"));
+    ioChain1.addNode(new Agent2("agent2"));
+
+    SequentialChain ioChain2 = new SequentialChain();
+    ioChain2.addNode(new Agent1("agent3"));
+    ioChain2.addNode(new Agent2("agent4"));
+    ioChain2.addNode(ioChain1);
+
+    Object result = ioChain2.executeForResult("your params");
+    System.out.println(result);
+}
+```
+
+The above code implements Agents orchestration as shown in the diagram below:
+
+![](../../assets/images/chians-01.png)
+
+The data flow is as follows: `agent3` --> `agent4` --> `chain1`, and within `chain1`, there is the process of `agent1` --> `agent2`.
+
+
+In Agents-Flex, we have built-in three different types of Agents execution chains:
+
+- **SequentialChain**: Executes agents sequentially.
+- **ParallelChain**: Executes agents concurrently (in parallel).
+- **LoopChain**: Executes agents in a loop.
+
+Moreover, each of these three chains can serve as a sub-chain for other chains, thus forming powerful and complex Agents chains.
+