AI Agent编程语言开源发布

我为什么要设计一个 AI Agent DSL编程语言

这不是一篇教程，是一篇关于"为什么要做这件事"的思考记录。

如果你是 Java 开发者，正在考虑在项目里引入 AI Agent 能力，这篇文章可能对你有用。

一切从一段代码开始

讲个故事：去年我在一个企业项目里需要实现一个"智能客服 Agent"：读取用户问题、检索内部知识库、必要时调用 CRM 接口查询客户信息、最后给出回答。

我选择了 LangChain4j，Java 生态里最成熟的 LLM 集成库。写出来的代码大概长这样：

java 复制代码

// 用 LangChain4j 实现一个带工具的 Agent
ChatLanguageModel model = OpenAiChatModel.builder()
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .modelName("gpt-4o")
    .temperature(0.7)
    .build();

MessageWindowChatMemory memory = MessageWindowChatMemory.withMaxMessages(20);

// 定义工具
ToolSpecification queryCustomerTool = ToolSpecification.builder()
    .name("queryCustomer")
    .description("根据客户 ID 查询客户信息")
    .addParameter("customerId", JsonSchemaProperty.STRING, 
                  JsonSchemaProperty.description("客户唯一标识"))
    .build();

ToolExecutor queryCustomerExecutor = (request, memoryId) -> {
    String args = request.arguments();
    // 解析 JSON 参数...
    JsonObject json = JsonParser.parseString(args).getAsJsonObject();
    String customerId = json.get("customerId").getAsString();
    return crmService.queryCustomer(customerId);
};

// 构建 RAG 检索器
EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .modelName("text-embedding-3-small")
    .build();

InMemoryEmbeddingStore<TextSegment> store = new InMemoryEmbeddingStore<>();
// ... 向量化知识库文档 ...

ContentRetriever retriever = EmbeddingStoreContentRetriever.builder()
    .embeddingStore(store)
    .embeddingModel(embeddingModel)
    .maxResults(5)
    .build();

// 手动组装消息循环
List<ChatMessage> messages = new ArrayList<>();
messages.add(SystemMessage.from("你是一个专业的客服助手..."));

// 对话循环
String userMessage = "帮我查一下客户 C001 的订单状态";
messages.add(UserMessage.from(userMessage));

while (true) {
    ChatResponse response = model.chat(
        ChatRequest.builder()
            .messages(messages)
            .toolSpecifications(List.of(queryCustomerTool))
            .build()
    );
    
    AiMessage aiMessage = response.aiMessage();
    messages.add(aiMessage);
    
    if (!aiMessage.hasToolExecutionRequests()) {
        System.out.println(aiMessage.text());
        break;
    }
    
    for (ToolExecutionRequest req : aiMessage.toolExecutionRequests()) {
        String result = queryCustomerExecutor.execute(req, "default");
        messages.add(ToolExecutionResultMessage.from(req, result));
    }
}

这段代码能跑，但我不满意。

不是说 LangChain4j 不好------它是一个优秀的底层库，提供了丰富的 LLM 集成能力。但是当我需要定义一个 Agent 的时候，我写的大部分代码都是胶水：创建 Builder、组装对象、管理消息列表、处理工具调用循环......

我真正想表达的意图，其实只有这些：

这个 Agent 用 GPT-4o，带记忆，能查询客户信息，用知识库回答问题。

这几句话翻译成代码，要写 80 行。

问题的本质

我开始思考：为什么 Python 的 AI 开发者写起来感觉更轻松？

答案不是 Python 比 Java 更适合 AI，而是 Python 生态里有 LangChain、CrewAI 这些更高抽象层的框架，它们把"描述 Agent 是什么"和"Agent 怎么运行"两件事分开了。

Java 生态里，LangChain4j 是底层执行引擎，但缺少声明式的抽象层。每个开发者都在自己的项目里重复写同样的胶水代码。

这就是我决定做 AgentDSL 的原因：填补 Java 生态里的声明式 Agent 抽象层。

AgentDSL 是什么

一句话：用 Groovy DSL 语法声明式地定义 AI Agent，框架负责编译、校验和执行。

同样的智能客服 Agent，用 AgentDSL 写是这样的：

groovy 复制代码

// customer-service.agent.groovy

agent('customer-service') {
    description '智能客服助手，可查询客户信息并基于知识库回答问题'

    model {
        provider 'openai'
        modelName 'gpt-4o'
        temperature 0.7
    }

    systemPrompt '你是一个专业的客服助手，用中文回答问题，保持友好和专业。'

    memory {
        type 'message_window'
        maxMessages 20
    }

    tools {
        tool('queryCustomer') {
            description '根据客户 ID 查询客户信息和订单状态'
            parameter {
                name 'customerId'
                type 'string'
                description '客户唯一标识'
                required true
            }
            execute { params ->
                // 直接写业务逻辑
                return crmService.queryCustomer(params.customerId)
            }
        }
    }

    rag {
        contentRetriever {
            type 'embedding_store'
            embeddingModel 'text-embedding-3-small'
            maxResults 5
        }
    }
}

运行：

bash 复制代码

./shell/agentdsl.sh run customer-service.agent.groovy \
  --chat "帮我查一下客户 C001 的订单状态"

这才是我想要的表达方式：描述 Agent 是什么，而不是怎么做。

核心特性总览

特性	说明
Workflow 工作流	顺序、并行、条件路由、循环四种模式，支持 agent / execute / tool / skill / mcp 五类节点，混合编排 AI 推理与确定性逻辑
内置工具	HTTP、JSON、文件、Excel、PDF、数据库、网络搜索、命令执行、图像识别、代码执行（Groovy/Shell/Python）等，`include` 即用
Skill 技能	Prompt 型（描述驱动 LLM）与 Logic 型（Groovy 闭包执行业务逻辑），支持 `includeFile` 加载外部 `.skill.md`
MCP 一等公民	标准 MCP Server 挂载，GitHub、Slack、Playwright 等生态工具即插即用
Spring Boot	`agentdsl-spring-boot-starter` 自动配置、脚本扫描、REST API、热加载，嵌入现有 Web 应用
Autonomous Agent	规划-确认-执行的人机协作模式，`max_steps` 可控边界

三个核心设计决策

在设计 AgentDSL 的过程中，有三个决策我认为是值得说明的。

决策一：为什么选 Groovy DSL，而不是 YAML 或注解

我考虑过三种方案：

YAML 配置（像 Dify 那样）：上手最简单，但无法内联业务逻辑，一旦工具执行逻辑复杂就需要外部引用。

Java 注解（像 Spring 那样）：对 Java 开发者最熟悉，但注解无法表达动态逻辑，嵌套结构也很受限。

Groovy DSL ：利用 Groovy 的闭包委托机制，既能写声明式的结构，又能在 execute { } 块里写完整的业务逻辑。对 Java 开发者来说，Groovy 语法几乎零学习成本。

最重要的是，.agent.groovy 文件有编译期校验------模型 provider 写错了、必填字段漏了，在运行前就能发现。这是 YAML 做不到的。

决策二：MCP 作为一等公民

Model Context Protocol 是 2024 年底 Anthropic 提出的工具互操作标准，正在快速成为 AI 工具生态的连接器。GitHub、Slack、数据库、浏览器......越来越多的服务提供了标准的 MCP Server。

AgentDSL 从设计之初就把 MCP 作为一等公民，而不是事后添加的插件：

groovy 复制代码

agent('developer-agent') {
    model { provider 'claude'; modelName 'claude-opus-4-6' }
    systemPrompt '你是一个代码审查助手。'

    mcp {
        server('github') {
            transport 'stdio'
            command 'npx', '-y', '@modelcontextprotocol/server-github'
            env 'GITHUB_TOKEN', env('GITHUB_TOKEN')
        }
        // 只暴露需要的工具，减少 token 消耗
        filterTools 'list_pull_requests', 'get_pull_request', 'create_review'
    }
}

Agent 启动时会自动启动 MCP Server 进程，管理生命周期，把 MCP 工具转换为 LangChain4j 的 ToolSpecification。开发者不需要了解 MCP 协议的任何细节。

决策三：Autonomous Agent 的控制权问题

很多 Agent 框架追求"最大自主性"------给 Agent 一个目标，让它自由运行。这在 Demo 里很酷，但在企业生产环境里不够安全。

AgentDSL 的 Autonomous Agent 设计了一套人机协作机制：

groovy 复制代码

agent('research-agent') {
    model { provider 'gemini'; modelName 'gemini-2.5-flash' }
    systemPrompt '你是一个自主研究助手。'
    
    tools {
        include 'web_search'
        include 'file_write'
    }

    autonomous {
        execution_mode 'plan'   // 先生成计划，用户确认后再执行
        max_steps 15            // 超过 15 步暂停，询问用户是否继续
    }
}

plan 模式下，Agent 会先生成完整的执行计划，展示给用户确认，再开始执行。max_steps 到达上限时，不是直接报错，而是暂停并告知当前进展，由用户决定是否继续。

这个设计的核心理念是：自主不等于失控，Agent 应该在可预期的边界内自主。

一个能跑的完整示例

下面演示一个真实可用的场景：让 Agent 自主完成一个竞品分析任务。

第一步：克隆和构建

bash 复制代码

git clone https://github.com/wuguirongsg/AgentDSL.git
cd AgentDSL
./gradlew :agentdsl-cli:shadowJar

构建完成后在 agentdsl-cli/build/libs/ 下生成 agentdsl.jar。

第二步：配置 API Key

bash 复制代码

# 使用 Gemini（有免费额度，推荐新手）
export GEMINI_API_KEY="your-key"

# 或者本地 Ollama（完全免费，需要提前安装）
# 无需配置 key

第三步：创建 Agent 脚本

创建文件 research.agent.groovy：

groovy 复制代码

agent('researcher') {
    model {
        provider 'gemini'
        modelName 'gemini-2.5-flash'
        temperature 0.3
    }

    systemPrompt '''你是一个技术调研助手。
    完成调研后，将结果整理成 Markdown 报告保存到文件。
    所有步骤完成后输出 TASK_COMPLETE: [摘要]'''

    tools {
        include 'web_search'
        include 'file_write'
        include 'file_read'
    }

    autonomous {
        execution_mode 'plan'
        max_steps 12
    }
}

第四步：运行

bash 复制代码

shell/agentdsl.sh run examples/research.agent.groovy --autonomous "调研 Java 生态下主流的 AI Agent 框架，给我一份竞品分析报告，保存到 /tmp/java-ai-report.md"

运行过程（节选真实输出）：

less 复制代码

════════════════════════════════════════════════════════════
📋 自主 Agent 执行计划
════════════════════════════════════════════════════════════
🎯 目标: 调研 Java 生态下主流的 AI Agent 框架，给我一份竞品分析报告，保存到 /tmp/java-ai-report.md

💡 规划思路: 首先利用 `web_search` 工具在互联网上调研 Java 生态下主流的 AI Agent 框架，并要求工具将检索结果提炼为竞品分析报告所需的内容。然后，将提炼出的报告内容使用 `file_write` 工具保存到指定的文件路径。

📋 执行计划:
  1. 调研 Java AI Agent 框架并生成竞品分析报告内容 [使用: web_search]
  2. 保存竞品分析报告到文件 [使用: file_write]

────────────────────────────────────────────────────────────
请选择操作:
  [y] 确认执行此计划
  [m] 修改计划（输入修改建议）
  [n] 取消执行
>>> y
✅ 计划已确认，开始执行...
🔄 步骤 1/12...   🔧 web_search → Error: 不支持的搜索提供商 'List mainstream Java AI Agent frameworks, their key features, pros and cons, and use cases for a compe...🔄 步骤 2/12...   🔧 web_search → 搜索结果摘要如下：

- 标题: AI Agent 开发框架哪家强？主流Agent 框架盘点原创 - CSDN博客
  链接: https://blog.csdn.net/Y525698136/article/details/1499288...🔄 步骤 3/12...   🔧 web_search → Error: 不支持的搜索提供商 '列出主流的Java AI Agent框架，包括它们的特点、优缺点和适用场景，用于竞品分析报告。'。目前仅支持: tavily, serper, zhipu。🔄 步骤 4/12...   🔧 web_search → 搜索结果摘要如下：

- 标题: Java 生态AI Agent 框架技术选型分析报告 - 知乎专栏
  链接: https://zhuanlan.zhihu.com/p/2006323907385397921
  内容: AgentSco...🔄 步骤 5/12...🔄 步骤 6/12...   🔧 web_search → Error: 不支持的搜索提供商 'LangChain4j的特点、优缺点和适用场景'。目前仅支持: tavily, serper, zhipu。   🔧 web_search → Error: 不支持的搜索提供商 'Spring AI的特点、优缺点和适用场景'。目前仅支持: tavily, serper, zhipu。   🔧 web_search → Error: 不支持的搜索提供商 'Agent-Flex的特点、优缺点和适用场景'。目前仅支持: tavily, serper, zhipu。   🔧 web_search → Error: 不支持的搜索提供商 'AgentScope-Java的特点、优缺点和适用场景'。目前仅支持: tavily, serper, zhipu。🔄 步骤 7/12...   🔧 web_search → 搜索结果摘要如下：

- 标题: LangChain学习系列之LangChain4j介绍原创 - CSDN博客
  链接: https://blog.csdn.net/wuchsh123/article/details/148410015
...10:54:37.504 INFO  [main] c.a.r.autonomous.AutonomousExecutor - [researcher] 消息历史已压缩，当前 7 轮
🔄 步骤 8/12...   🔧 web_search → 搜索结果摘要如下：

- 标题: Agents-Flex/Agents-Flex
  链接: https://gitee.com/agents-flex/agents-flex
  内容: 一个优雅的Java LLM 应用开发框架| 真开源...🔄 步骤 9/12...   🔧 web_search → 搜索结果摘要如下：

- 标题: Java 生态AI Agent 框架技术选型分析报告 - 知乎专栏
  链接: https://zhuanlan.zhihu.com/p/2006323907385397921
  内容: 优势：技术先进性...🔄 步骤 10/12...🔄 步骤 11/12...10:55:02.268 INFO  [ForkJoinPool.commonPool-worker-1] com.agentdsl.tools.builtin.FileTool - 写入文件: /tmp/java-ai-report.md (1784 bytes)
   🔧 file_write → Successfully wrote 1784 bytes to /tmp/java-ai-report.md🔄 步骤 12/12...✅ 任务完成

════════════════════════════════════════════════════════════
Java 生态下主流 AI Agent 框架竞品分析报告已生成并保存到 /tmp/java-ai-report.md。报告涵盖了 LangChain4j、Spring AI、Agent-Flex 和 AgentScope-Java 四个框架的特点、优缺点和适用场景。
════════════════════════════════════════════════════════════
📊 执行了 10 步，耗时 62720ms，✅ 目标已完成

竞品分析报告的内容：java-ai-report.md

markdown 复制代码

# Java AI Agent 框架竞品分析报告

## 1. LangChain4j

*   **特点**:
    *   专注于智能Agent、多步骤推理和自定义AI工作流的开源框架。
    *   提供链式调用、Agent管理、记忆存储、工具集成等高级功能。
    *   与LangChain相比，更贴合Java开发者的编程习惯和技术栈，能够与Java的各种库、框架无缝集成，如Spring、Hibernate等。
    *   提供统一API，支持15+个流行的LLM提供商和20+个嵌入商店。
    *   支持RAG（检索增强生成）、函数调用、多模态。
*   **优点**:
    *   健壮的生态系统，拥有详尽的文档和社区支持。
    *   高兼容性，能很好地配合各种Java框架和库使用。
    *   模块化设计，允许开发者只使用所需组件。
*   **缺点**:
    *   可能需要一定的学习成本来掌握其高级功能和概念。
*   **适用场景**:
    *   需要快速原型设计、高度灵活性以及跨平台协作的AI应用。
    *   特别适用于NLP、推荐算法和其他依赖于外部服务集成的场景。

## 2. Spring AI

*   **特点**:
    *   基于Spring框架体系，旨在帮助Java开发者简化AI应用的开发，提供方便的API抽象。
    *   提供完整的开源配套，包括可观测、网关、消息队列、配置中心等。
    *   已完整提供Model、Prompt、RAG、Tools等AI应用开发所需的必备能力。
    *   兼具提示词模板、函数调用、格式化输出等低层次抽象，以及RAG、智能体、对话记忆等高层次抽象。
*   **优点**:
    *   与Spring生态系统无缝集成，简化开发流程，充分利用Spring框架的优点。
    *   对于Spring开发者而言，学习曲线平缓，易于上手。
*   **缺点**:
    *   对于非Spring用户来说，可能需要额外学习Spring框架知识。
*   **适用场景**:
    *   已经采用Spring框架体系构建的企业级应用。
    *   注重系统稳定性和安全性、寻求将AI能力无缝融入现有IT基础设施中的组织。
    *   适用于内部数据驱动型决策支持系统、个性化营销和服务优化等领域。

## 3. Agent-Flex

*   **特点**:
    *   一个优雅的Java LLM应用开发框架，专为Java工程师与架构师设计。
    *   提供轻量、模块化、可扩展的AI智能体开发体验。
    *   灵感来源于LangChain、LlamaIndex。
*   **优点**:
    *   轻量、模块化、可扩展，易集成。
    *   简化AI应用开发。
*   **缺点**:
    *   相较于LangChain4j和Spring AI，社区活跃度和文档可能仍在发展中。
*   **适用场景**:
    *   需要快速构建AI应用的Java开发者。
    *   对轻量级和模块化有要求的场景。

## 4. AgentScope-Java

*   **特点**:
    *   阿里巴巴推出的面向智能体的编程框架，用于构建基于大语言模型的应用。
    *   以开发者为核心，专注于智能体开发，解决智能体在构建、运行和管理中的难题。
    *   提供一套覆盖"开发、部署、调优"全生命周期的生产级解决方案。
    *   原生为Agentic范式设计，核心是"Agent"，旨在帮助构建以Agent为中心、具备自主思考和行动能力的智能应用。
*   **优点**:
    *   技术先进性高，可扩展性强。
    *   提供生产级解决方案，覆盖全生命周期管理。
    *   适合复杂场景。
*   **缺点**:
    *   由于是较新的框架，生态系统和社区支持可能仍在发展中。
*   **适用场景**:
    *   构建复杂的企业级多Agent系统。
    *   智能客服、自动化流程、机器人控制等场景。

工作流编排 (Workflow)

AgentDSL 支持声明式工作流，将多个 Agent、工具、技能编排成流水线。支持顺序、并行、条件路由、循环四种执行模式：

groovy 复制代码

workflow('translate-pipeline') {
    steps {
        // 顺序步骤：翻译 → 审核 → 修订（循环直到通过）
        step('translate') {
            agent 'translator'
            input { text -> "请翻译：\n${text}" }
        }
        loop(maxIterations: 3) {
            step('review') { agent 'reviewer'; input { it } }
            until { result -> result.toString().trim().equalsIgnoreCase('pass') }
            step('revise') { agent 'translator'; input { it } }
        }
    }
}

workflow('multi-analysis') {
    steps {
        // 并行步骤：情感分析 + 关键词提取，同时执行
        parallel {
            step('sentiment') { agent 'sentiment-analyzer' }
            step('keywords') { agent 'keyword-extractor' }
        }
        step('report') { agent 'report-generator'; input { "分析结果：${it}" } }
    }
}

workflow('quality-format') {
    steps {
        step('assess') { agent 'reviewer'; input { it } }
        // 条件路由：根据评估结果走不同分支
        condition {
            check { result -> result.contains('premium') ? 'premium' : 'standard' }
            on('premium') { step('premium-format') { agent 'premium-formatter' } }
            on('standard') { step('standard-format') { agent 'standard-formatter' } }
        }
    }
}

工作流还支持直接执行节点 （零 Token 消耗）：execute { ctx -> ... } 纯代码、tool "工具名" 直接调工具、skill "技能名" 直接调 Logic Skill、mcp "server", "tool" 直接调 MCP 工具。可与认知节点 agent "xxx" 混合编排，实现「确定性逻辑 + AI 推理」的混合流水线。

内置工具 (Built-in Tools)

AgentDSL 内置了企业场景常用的工具，include 一行即可使用：

groovy 复制代码

tools {
    // HTTP & 数据处理
    include 'http_get'        // HTTP GET 请求
    include 'http_post'       // HTTP POST 请求
    include 'json_parse'      // JSON 解析
    include 'json_query'      // JSONPath 查询

    // 文件处理
    include 'file_read'       // 读取文件
    include 'file_write'      // 写入文件
    include 'excel_read'      // 读取 Excel
    include 'excel_write'     // 写入 Excel
    include 'pdf_read'        // 提取 PDF 文本
    include 'image_recognize' // 图像识别

    // 数据与搜索
    include 'db_query'       // JDBC 数据库查询
    include 'db_execute'     // JDBC 数据库执行
    include 'web_search'     // 实时网络搜索（Tavily/Serper/智谱）

    // 自动化
    include 'cmd_execute'    // 执行本地命令

    // 代码执行（v1.4，生产环境建议启用安全沙箱）
    include 'groovy_execute'    // 执行 Groovy 代码，适合轻量数据处理
    include 'shell_script_run'  // 执行 Shell/Bat/PowerShell 脚本
    include 'python_run'        // 执行 Python 代码
}

对于需要浏览器自动化的场景，有专门的配置块：

groovy 复制代码

agent('web-agent') {
    // ...
    browser_use {
        sandbox false
        hitl_on 'click', 'fill'  // 点击和输入前需要人工确认
    }
}

技能系统 (Skill)

Skill 是比 Tool 更高层的抽象，分为两类：

Prompt Skill ：描述型，通过 instruction 注入到 LLM 系统提示中，驱动模型按特定方式完成任务（如「严格输出 JSON」）。
Logic Skill：逻辑型，通过 Groovy Closure 实现多步骤业务逻辑，可调用工具、访问外部 API，执行结果 100% 确定。

groovy 复制代码

// Prompt Skill：不写代码，只描述行为
skill('json-formatter') {
    type 'prompt'
    description '当需要将文本转换为 JSON 时调用'
    instruction '你是一个严格的数据抽取机器，只返回 JSON 代码块。'
}

// Logic Skill：写业务逻辑，可调用工具
skill('weather-api-logic') {
    type 'logic'
    description '当需要查询天气时调用'
    parameter { name 'location'; type 'string'; required true }
    execute { params ->
        toolCall('http_get', [url: "https://api.weather.com?city=${params.location}"])
    }
}

agent('assistant') {
    model {
        provider 'gemini'
        modelName 'gemini-2.5-flash'
    }
    systemPrompt '你是一个能灵活运用技能的助手。'

    skills {
        include 'json-formatter'
        include 'weather-api-logic'
        includeFile 'skills/brand.skill.md'  // 支持外部 .skill.md 文件
    }
}

Skill 可在 Workflow 中作为技能节点直接调用，实现「确定性步骤 + AI 步骤」的混合编排。

支持的大模型

这是我在设计时特别关注的一点------国内企业用户有大量国产模型的使用需求，但大多数开源框架对国产模型的支持非常潦草。

AgentDSL 目前支持：

Provider	模型示例
OpenAI	gpt-4o, gpt-4o-mini
Anthropic	claude-opus-4-6, claude-sonnet-4-6
Google	gemini-2.5-flash, gemini-2.5-pro
Ollama	qwen3:4b, llama3.3（本地运行）
豆包	doubao-pro-32k
通义千问	qwen-max, qwen-plus
智谱 GLM	glm-4, glm-4-flash
DeepSeek	deepseek-chat, deepseek-reasoner
Kimi / Moonshot	moonshot-v1-32k
MiniMax	minimax-2.5

切换模型只需要改两行 DSL：

groovy 复制代码

model {
    provider 'doubao'
    modelName 'doubao-pro-32k'
}

Spring Boot 集成

如果你想把 AgentDSL 嵌入到现有的 Spring Boot 项目里，可以使用 agentdsl-spring-boot-starter：

groovy 复制代码

// build.gradle
dependencies {
    implementation 'com.agentdsl:agentdsl-spring-boot-starter:0.1.0-SNAPSHOT'
}

yaml 复制代码

# application.yml
agentdsl:
  enabled: true
  scripts-location: classpath:agents/   # 或 file:./agents/
  hot-reload: true                      # 开发时热加载 DSL 脚本
  sandbox: true
  api:
    enabled: true
    base-path: /api                      # REST API 基础路径

启动后，框架会自动扫描 agents/ 目录下的 .agent.groovy 脚本，注册 Agent 和 Workflow，并暴露 REST 接口：GET /api/agents、POST /api/agents/{name}/chat、GET /api/workflows、POST /api/workflows/{name}/execute。支持热加载，修改脚本后无需重启即可生效。

当前的局限

这个项目目前是早期版本，有些能力还在完善中：

Spring Boot Starter 持续迭代 ：agentdsl-spring-boot-starter 已提供自动配置、脚本扫描、REST API、热加载等能力，可满足将 Agent 嵌入 Web 应用的基本需求。与 Spring 生态的深度集成（如与 Spring AI 联动、更丰富的 Bean 注入）仍在演进。

多 Agent 协作尚未实现：多个 Agent 之间互相通信、共享状态、事件驱动协作，这是 v2.0 的规划方向。当前版本通过 Workflow 的顺序/并行步骤来编排多个 Agent，但不支持 Agent 间直接对话。

Groovy 的双重门槛：如果你的团队既不熟悉 Groovy，又没接触过 DSL 概念，上手成本会比预期高一些。文档里有完整的语言规范，但这仍然是需要投入学习的。

依赖 LangChain4j beta 版本：LangChain4j 本身还在快速演进，API 稳定性不如一些更成熟的库，这是一个已知的架构风险。

后续规划

AgentDSL 的演进方向已初步明确，欢迎社区参与讨论和贡献：

方向	说明
内置元 Agent	引入元 Agent 能力，支持 Agent 自行开发、自我优化和系统自动调优
Autonomous 深入优化	当前仅实现基础 ReAct 模式。规划增强：问题接受与解构（理解并拆解复杂任务）、策略规划（多步规划与资源分配）、ReAct 模式深化、元认知监控（自我反思与纠错）
插件化开发模式	引入插件机制，便于集成更多第三方能力（模型、工具、数据源等），降低扩展成本
RAG 增强与长期记忆	增强 RAG 检索能力，引入长期记忆存储，支持跨会话的知识沉淀与复用
Rules 规则限定与经验总结	支持 Rules 规则约束 Agent 行为；基于执行记忆进行经验总结，形成可复用的最佳实践
多 Agent 协作	多个 Agent 之间互相通信、共享状态、事件驱动协作，支持更复杂的任务分工与协同

最后

这个项目从一个个人痒点出发，填补的是一个真实但小众的空白：Java 生态里的声明式 AI Agent 开发体验。

它不是 OpenHands，也不是 Dify，它的目标用户是想在 Java 项目里优雅地使用 AI Agent 的工程师，而不是用图形界面拖拖拽拽的产品人员，也不是主要做代码生成的 AI 工程师。

如果你恰好是这个用户，欢迎来试试：

GitHub : github.com/wuguirongsg...

GitEE : gitee.com/wuguirong/a...

项目提供语言规范 、用户指南 、架构与扩展文档，不想手写 DSL 的话，直接把文档喂给大模型，描述你想要的 Agent，AI 会帮你生成可运行的脚本------连图形化拖拽都省了。

不想手写代码？把文档喂给 AI，ps：这也是后续规划的metaAgent的特性之一

如果你不想手写 agentDSL，也不想用图形化拖拽构建------项目提供了完整的文档，直接把语法定义和用户指南喂给任意大模型，让 AI 帮你生成你需要的 Agent。你只需要说清楚：你想要什么样的 Agent、具备哪些能力、对接哪些工具。

文档	路径	用途
语言规范	`doc/lang-spec/AIAgentDSL-Language-Spec-v1.4.md`	权威的语法、关键字、语义定义，供 LLM 精确生成合法 DSL
用户入门指南	`doc/User_Guide_zh-CN.md`	快速上手教程、示例与最佳实践，供 LLM 理解常见用法
架构与扩展指南	`doc/Architecture_Guide_zh-CN.md`	系统架构、SPI 扩展、二次开发说明，供 LLM 生成自定义模型/工具集成

推荐用法：把「语言规范 + 用户指南」作为上下文喂给 Claude / GPT / 通义 / 智谱等，然后描述你的需求，例如：

帮我写一个 AgentDSL 脚本：一个智能客服 Agent，用 Gemini 模型，能查数据库、能读 Excel，带 20 条消息记忆，系统提示词要专业友好。

AI 会直接输出可运行的 .agent.groovy 代码，你保存后 validate 校验、run 执行即可。连图形化拖拽的功夫都省了------说明清楚你想要什么，代码就来了。

有 Bug、有想法、有疑问，都欢迎提 Issue。项目刚开始，每一个 Star 和每一条反馈对我都很重要。

ps：项目99%的代码都是vibecode，主要用了gemini3.1, claude4.6, glm5, minimax2.5，这些模型来开发，本人只提供了创意想法和设计方向的指导, 感谢ai的帮助

写于 2026 年 3 月