一个 AI Coding Agent，三种框架实现：Java / AgentScope Python / LangGraph 全景对比

武汉红喜

43人浏览 · 2026-07-25 15:54:44

武汉红喜 · 2026-07-25 15:54:44 发布

AgentScope Java 2.0 | Spring Boot 4.1 | LangGraph | AgentScope Python | FastAPI | Java + Python 双语言

你是否好奇：同一个 AI Coding Agent 的设计，用 Java 和 Python 分别实现，会碰撞出怎样的火花？

市面上的 AI 编程助手要么只讲 Python 生态，要么只展示 Java 的企业级能力——很少有人用同一套设计理念，跨语言、跨框架地实现三遍，然后告诉你：哪些设计是通用的，哪些是框架特有的。

Babi Agent 就是这么做的——同一个 Coding Agent 概念，分别用 AgentScope Java + Spring Boot、AgentScope Python + FastAPI、LangGraph + LangChain + FastAPI 三种技术栈完整实现，覆盖代码读写、Shell 执行、网页抓取、Web 搜索、GitHub 集成、Skills 扩展等全流程能力。

🎯 为什么要把同一个 Agent 写三遍？

动机一：Java 和 Python 的 AI Agent 生态各有所长

Python 有 LangChain、LangGraph、AgentScope 等成熟的 Agent 框架，生态丰富、迭代迅速。Java 有 Spring Boot 的企业级能力——依赖注入、WebFlux 响应式流、类型安全——但 AI Agent 框架相对稀缺。

如果只写一种语言，你永远不知道另一种语言的框架设计得有多好（或多差）。

动机二：Agent 框架选型不应该靠猜

LangGraph 的 create_react_agent 和 AgentScope Java 的 HarnessAgent，底层都是 ReAct 模式，但 API 设计、工具注册、会话持久化、流式输出的实现方式截然不同。只有亲手用两个框架写一遍，你才能说出它们各自的优劣。

动机三：好的设计是跨语言的

Skills 系统、工具事件总线、工作区管理、系统提示词构建——这些核心设计在三种实现中几乎一模一样。如果一种设计在 Java 和 Python 中都能优雅地实现，那它大概率是一个好设计。

🏗️ 三项目全景：同一理念，三种表达

项目矩阵

维度	babi (Java)	babi-agentscope (Python)	babi-langgraph (Python)
核心框架	AgentScope Java 2.0	AgentScope Python SDK	LangGraph + LangChain
Web 框架	Spring Boot 4.1 (WebFlux)	FastAPI + Uvicorn	FastAPI + Uvicorn
CLI 框架	Spring Boot (exec:java)	Click	Click
ReAct 引擎	HarnessAgent (内置)	Agent (内置)	create_react_agent
模型接入	DashScope 原生 SDK	DashScope 原生 SDK	ChatOpenAI 兼容 API
会话持久化	JSON 文件 (~/.babi/sessions/)	Redis	PostgreSQL / MemorySaver
工具事件	ToolEventBus (Reactor Sinks)	InMemoryMessageBus	astream_events
启动命令	`mvn spring-boot:run`	`babi-as`	`babi-lg`

共同的特性

三个项目不是"各写各的"，而是共享同一套设计语言：

9+ 内置工具：代码读写、搜索、Shell 执行、网页抓取、Web 搜索、HTTP 请求、GitHub 集成
Skills 扩展系统：Markdown 定义、三级加载（全局 / Babi 专属 / 项目级）
Web + CLI 双端交互：SSE 流式输出 + 终端 REPL
工作区管理：默认当前目录，AGENTS.md 自动注入
系统提示词：相同的核心规则（Tool-First、No Hallucination、GitHub API 优先）

🔬 核心设计深度对比

✨ 1. Agent 构建：Builder 模式 vs 工厂函数 vs 预构建函数

三种实现展示了 Agent 框架的三种不同设计哲学：

Java — HarnessAgent Builder 模式：

HarnessAgent.builder()
        .name("Babi")
        .sysPrompt(sysPrompt)
        .model(DashScopeChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .modelName("qwen-plus")
                .stream(true)
                .enableSearch(true)
                .build())
        .toolkit(toolkit)
        .workspace(workspacePath)
        .filesystem(new LocalFilesystemSpec()
                .project(workspacePath)
                .mode(LocalFsMode.UNRESTRICTED))
        .stateStore(stateStore)
        .maxIters(20)
        .maxRetries(2)
        .fallbackModel("qwen-turbo")
        .enableTaskList()
        .enablePlanMode()
        .allowShellInPlanMode()
        .middleware(new ContextTruncateMiddleware(30))
        .middleware(new ToolNotificationMiddleware(toolEventBus))
        .build();

Builder 模式的优势一目了然：20+ 个配置项链式调用，每个选项语义清晰。HarnessAgent 内置了计划模式、任务追踪、模型降级、中间件管道等能力，开发者只需"开关式"启用。

Python (AgentScope) — 工厂函数：

agent = Agent(
    name="BabiAgent",
    system_prompt=sys_prompt,
    model=DashScopeChatModel(
        credential=DashScopeCredential(api_key=settings.dashscope_api_key),
        model=settings.model_name,
        stream=True,
        max_retries=settings.max_retries,
    ),
    toolkit=Toolkit(tools=[
        Bash(), Grep(), Glob(), Read(), Write(), Edit(),
        FunctionTool(fetch_url),
        FunctionTool(http_request),
        FunctionTool(web_search),
        FunctionTool(github_api_request),
        FunctionTool(github_pinned_repos),
        FunctionTool(skill_tool.list_skills),
        FunctionTool(skill_tool.use_skill),
    ]),
    state=AgentState(
        permission_context=PermissionContext(mode=PermissionMode.BYPASS),
    ),
)

AgentScope Python 的 Agent 类更简洁——Toolkit 统一注册内置工具和自定义工具，FunctionTool 可以将普通 Python 函数直接包装为 Agent 工具。

Python (LangGraph) — 预构建函数：

agent = create_react_agent(
    model=llm,
    tools=tools,
    checkpointer=checkpointer,
    prompt=sys_prompt,
)

LangGraph 的 create_react_agent 是三者中最简洁的——一行代码创建一个完整的 ReAct Agent。但简洁的代价是灵活性：计划模式、模型降级、中间件管道等高级能力需要自行实现。

这意味着：Agent 框架的选型本质上是"开箱能力"与"灵活性"的权衡——HarnessAgent 开箱即用，LangGraph 极简但需要自建。

✨ 2. 工具系统：框架内置 vs 手写实现

三个项目的工具分为两类：框架提供的内置工具和开发者自定义的工具。

工具	Java (babi)	Python-AS (babi-agentscope)	Python-LG (babi-langgraph)
读文件	HarnessAgent 内置 `Read`	AgentScope 内置 `Read`	手写 `read_file` (@tool)
写文件	HarnessAgent 内置 `Write`	AgentScope 内置 `Write`	手写 `write_file` (@tool)
编辑文件	HarnessAgent 内置 `Edit`	AgentScope 内置 `Edit`	手写 `edit_file` (@tool)
代码搜索	HarnessAgent 内置 `Grep`	AgentScope 内置 `Grep`	手写 `grep_files` (@tool)
Glob	HarnessAgent 内置 `Glob`	AgentScope 内置 `Glob`	手写 `glob_files` (@tool)
Shell	HarnessAgent 内置 `Bash`	AgentScope 内置 `Bash`	手写 `shell_execute` (@tool)
网页抓取	自定义 `FetchUrlTool`	自定义 `fetch_url`	自定义 `fetch_url`
Web 搜索	模型内置 enableSearch	自定义 `web_search` (Tavily)	自定义 `web_search` (Tavily)
HTTP 请求	自定义 `HttpRequestTool`	自定义 `http_request`	自定义 `http_request`
GitHub API	自定义 `GitHubApiTool`	自定义 `github_api_request`	自定义 `github_api_request`
Skills	自定义 `SkillTool`	自定义 `SkillTool`	自定义 `SkillTool`

一个有趣的发现：Java 和 AgentScope Python 的文件系统/Shell 工具完全由框架提供，开发者只需要写自定义工具（网页抓取、GitHub 等）。而 LangGraph 版本需要手写所有工具——包括 read_file、shell_execute 这些基础操作。

以 LangGraph 版本的 edit_file 为例：

@tool
def edit_file(file_path: str, old_text: str, new_text: str) -> str:
    """Edit a file by replacing exact text matches."""
    try:
        path = os.path.expanduser(file_path)
        with open(path, "r", encoding="utf-8") as f:
            content = f.read()
        count = content.count(old_text)
        if count == 0:
            return f"Error: Text not found in {file_path}."
        if count > 1:
            return f"Error: Text found {count} times. old_text must be unique."
        new_content = content.replace(old_text, new_text, 1)
        with open(path, "w", encoding="utf-8") as f:
            f.write(new_content)
        return f"Successfully edited {file_path}"
    except Exception as e:
        return f"Error editing file: {e}"

这意味着：LangGraph 给你最大的自由度，但也要求你写最多的代码。AgentScope 和 HarnessAgent 帮你把基础工具做好了，你只需要关注差异化能力。

✨ 3. 会话持久化：三种策略各有所长

实现	存储后端	机制	特点
babi (Java)	JSON 文件	`JsonFileAgentStateStore`	零依赖，文件级持久化
babi-agentscope	Redis	`RedisStorage`	高性能，支持多进程/分布式
babi-langgraph	PostgreSQL / Memory	`AsyncPostgresSaver` / `MemorySaver`	关系型持久化 or 纯内存

Java 版本最轻量——会话以 JSON 文件存储在 ~/.babi/sessions/，不需要任何外部服务：

@Bean
public AgentStateStore agentStateStore() {
    Path sessionPath = Paths.get(System.getProperty("user.home"), ".babi", "sessions");
    return new JsonFileAgentStateStore(sessionPath);
}

AgentScope Python 版本选择 Redis——天然适合 FastAPI 的异步场景和多进程部署：

storage = RedisStorage(host="localhost", port=6379)

LangGraph 版本最灵活——PostgreSQL 用于生产环境，MemorySaver 用于开发调试，通过环境变量 BABI_PG_DSN 一键切换：

pg_dsn = settings.pg_dsn
if pg_dsn:
    checkpointer = await AsyncPostgresSaver.from_conn_string(pg_dsn)
else:
    checkpointer = MemorySaver()  # 降级到内存

这意味着：三种持久化策略没有绝对的优劣——JSON 文件适合单机轻量场景，Redis 适合高性能 Web 服务，PostgreSQL 适合需要事务保证的生产环境。

✨ 4. 流式输出：Reactor Sinks vs SSE 直推 vs astream_events

三个项目都支持 SSE 流式输出，但实现方式各有特色：

Java — ToolEventBus + WebFlux：

ToolNotificationMiddleware ──发布──→ ToolEventBus ──订阅──→ SSE Controller ──推送──→ 前端
       (Agent 中间件)                 (Reactor Sinks)           (WebFlux SSE)

Java 版本设计了一个基于 Reactor Sinks.Many 的事件总线，通过 sessionId 隔离不同会话的事件流。中间件在 Agent 执行过程中发布事件，Controller 订阅后通过 SSE 推送给前端：

private final Sinks.Many<ToolEvent> sink =
        Sinks.many().multicast().onBackpressureBuffer(256, false);

AgentScope Python — agentscope.app.create_app：

AgentScope Python 的 Web 层直接复用框架的 create_app，SSE 由框架内置的 InMemoryMessageBus 管理，开发者只需关注自定义路由（工作区文件浏览、会话管理等）。

LangGraph Python — astream_events：

async for event in agent.astream_events(
    {"messages": [("user", request.message)]},
    config=config,
    version="v2",
):
    kind = event.get("event")
    if kind == "on_chat_model_stream":
        # Token 级流式输出
        yield f"data: {json.dumps({'type': 'token', 'content': chunk.content})}\n\n"
    elif kind == "on_tool_start":
        # 工具调用通知
        yield f"data: {json.dumps({'type': 'tool_call', 'tool': tool_name})}\n\n"

LangGraph 的 astream_events 是最直接的——事件流直接从 Agent 内部产生，无需中间件或事件总线。

这意味着：Java 的 ToolEventBus 最灵活（可独立订阅、扩展），AgentScope Python 最省心（框架全包），LangGraph 最直接（事件流开箱即用）。

✨ 5. Skills 系统：跨语言的统一设计

Skills 系统是三个项目中最一致的设计——无论 Java 还是 Python，加载逻辑几乎完全相同：

~/.agents/skills/    ← 全局共享技能（最低优先级）
~/.babi/skills/      ← Babi 专属技能（中等优先级，覆盖全局）
.qoder/skills/       ← 项目级技能（最高优先级，相对于工作区根目录）

加载规则：

支持扁平文件（my-skill.md）和目录格式（my-skill/SKILL.md）
同名 Skill 高优先级覆盖低优先级
YAML 前置元数据 + Markdown 正文

Java 版本（SkillLoader.java）：

public static Map<String, Skill> loadAll() {
    Map<String, Skill> skills = new LinkedHashMap<>();
    loadFromDir(GLOBAL_DIR, skills);      // 1. 全局（最低优先级）
    loadFromDir(BABI_DIR, skills);        // 2. Babi 专属（覆盖全局）
    Path projectSkillsDir = Path.of(System.getProperty("user.dir"))
            .resolve(PROJECT_SKILLS_DIR);
    loadFromDir(projectSkillsDir, skills); // 3. 项目级（最高优先级）
    return Collections.unmodifiableMap(skills);
}

Python 版本（loader.py）：

def load_all_skills(workspace_path: Path | None = None) -> dict[str, Skill]:
    skills: dict[str, Skill] = {}
    _load_from_dir(GLOBAL_DIR, skills)           # 1. 全局
    _load_from_dir(BABI_DIR, skills)             # 2. Babi 专属
    if workspace_path is not None:
        _load_from_dir(workspace_path / PROJECT_SKILLS_DIR, skills)  # 3. 项目级
    return skills

几乎是一比一的翻译——这正说明好的设计是跨语言的。Skills 的本质是"Markdown 文件 + 优先级覆盖"，这个设计不依赖任何特定语言或框架。

这意味着：你写一份 Skill 文件，在 Java 版、AgentScope Python 版、LangGraph 版中都能直接使用——零修改、零适配。

✨ 6. 系统提示词：同一套规则，三种实现

三个项目的系统提示词结构高度一致，都包含以下核心段落：

段落	作用
Workspace Context	注入工作区路径，强调"不要从历史对话猜测路径"
Core Rules	Tool-First、No Hallucination、No Self-Denial、Honest Reporting
GitHub Section	GitHub URL → API 映射规则
Skills Section	已加载技能列表 + 自动触发指令
Guidelines	通用行为准则 + 国内网络优先规则

其中 Core Rules 在三个项目中几乎逐字相同：

1. TOOL-FIRST RULE: When the user provides a URL, you MUST call fetch_url FIRST.
2. NO HALLUCINATION: NEVER fabricate content from a URL or file you haven't accessed.
3. NO SELF-DENIAL: NEVER claim a tool is "unavailable" unless you've tried it.
4. HONEST REPORTING: If a tool returns empty content, report that fact honestly.

LangGraph 版本额外增加了日期上下文（CURRENT DATE: 2026-07-25 (Saturday)），因为 LangGraph 的 Agent 不像 HarnessAgent 那样自动注入时间信息。

这意味着：系统提示词是 AI Coding Agent 的"灵魂"——无论底层框架如何变化，核心规则不变。

🏛️ 架构全景对比

Java 版 (babi)

                    +------------------------------+
                    |          用户端               |
                    |  Web 聊天界面  /  CLI 终端    |
                    +--------------+---------------+
                                   | SSE / stdin
                    +--------------+---------------+
                    |   BabiAgentController         |
                    |   (WebFlux SSE 流式输出)      |
                    +--------------+---------------+
                                   |
                    +--------------+---------------+
                    |      HarnessAgent             |
                    |  (ReAct + 计划模式 + 任务追踪) |
                    |  maxIters=20 / maxRetries=2   |
                    +--------------+---------------+
                                   |
            +----------------------+----------------------+
            |                      |                      |
   +--------+--------+   +--------+--------+   +---------+-------+
   |   内置工具       |   |  中间件          |   |  基础设施        |
   |  (Read/Write/   |   | Context         |   | ToolEventBus    |
   |   Edit/Grep/    |   | Truncate        |   | (Reactor Sinks) |
   |   Bash/Glob)    |   | Tool            |   |                 |
   +-----------------+   | Notification    |   | AgentStateStore |
                         +-----------------+   | (JSON 文件)     |
   +-----------------+                         | SkillLoader     |
   |   自定义工具     |                         +-----------------+
   | FetchUrl / Http |
   | GitHub / Skill  |
   +-----------------+

Python 版 (babi-agentscope)

                    +------------------------------+
                    |          用户端               |
                    |  Web 聊天界面  /  CLI 终端    |
                    +--------------+---------------+
                                   | SSE / stdin
                    +--------------+---------------+
                    |   agentscope.app.create_app   |
                    |   (FastAPI + MessageBus)      |
                    +--------------+---------------+
                                   |
                    +--------------+---------------+
                    |         Agent                 |
                    |    (AgentScope ReAct)          |
                    +--------------+---------------+
                                   |
            +----------------------+----------------------+
            |                      |                      |
   +--------+--------+   +--------+--------+   +---------+-------+
   |  框架内置工具     |   |  自定义工具       |   |  基础设施        |
   |  (Bash/Grep/    |   |  (fetch_url /    |   | RedisStorage    |
   |   Glob/Read/    |   |   http_request / |   | (会话持久化)     |
   |   Write/Edit)   |   |   web_search /   |   |                 |
   +-----------------+   |   github_api /   |   | SkillLoader     |
                         |   list/use_skill)|   +-----------------+
                         +-----------------+

Python 版 (babi-langgraph)

                    +------------------------------+
                    |          用户端               |
                    |  Web 聊天界面  /  CLI 终端    |
                    +--------------+---------------+
                                   | SSE / stdin
                    +--------------+---------------+
                    |      FastAPI App              |
                    |   (astream_events SSE)        |
                    +--------------+---------------+
                                   |
                    +--------------+---------------+
                    |   create_react_agent          |
                    |   (LangGraph ReAct)           |
                    +--------------+---------------+
                                   |
            +----------------------+----------------------+
            |                      |                      |
   +--------+--------+   +--------+--------+   +---------+-------+
   |  手写工具         |   |  自定义工具       |   |  基础设施        |
   |  (read_file /   |   |  (fetch_url /    |   | PG/Memory       |
   |   write_file /  |   |   http_request / |   | Checkpointer    |
   |   edit_file /   |   |   web_search /   |   | (会话持久化)     |
   |   grep_files /  |   |   github_api /   |   |                 |
   |   shell_execute)|   |   list/use_skill)|   | SkillLoader     |
   +-----------------+   +-----------------+   +-----------------+

📊 技术栈速查

组件	babi (Java)	babi-agentscope	babi-langgraph
Agent 框架	AgentScope Java 2.0	AgentScope Python	LangGraph 0.4 + LangChain 0.3
Web 框架	Spring Boot 4.1 (WebFlux)	FastAPI 0.115+	FastAPI 0.115+
CLI 入口	Spring Boot exec:java	Click + `babi-as`	Click + `babi-lg`
模型	DashScope SDK (qwen-plus)	DashScope SDK (qwen-plus)	ChatOpenAI 兼容 API
联网搜索	模型内置 enableSearch	Tavily API	Tavily API
会话存储	JSON 文件	Redis	PostgreSQL / Memory
前端	原生 HTML/JS (单文件)	原生 HTML/JS (共享)	原生 HTML/JS (共享)
构建工具	Maven	pyproject.toml + setuptools	pyproject.toml + setuptools
代码检查	-	ruff	ruff

💡 跨框架工程思考

1. 哪些设计是框架无关的？

通过三遍实现，我们验证了以下设计是真正通用的：

设计	说明
Skills 三级加载	全局 → Babi 专属 → 项目级，优先级覆盖
系统提示词结构	Workspace Context → Core Rules → GitHub → Skills → Guidelines
工具分类	文件系统 / 网络 / GitHub / Skills，边界清晰
SSE 事件类型	token / tool_call / tool_result / done，前端渲染逻辑一致
工作区语义	默认当前目录，AGENTS.md 自动注入
前端共享	三个项目使用完全相同的前端静态文件

2. 哪些设计是框架特有的？

能力	Java (HarnessAgent)	Python (AgentScope)	LangGraph
计划模式	✅ 内置	❌	❌ 需自建
任务追踪	✅ enableTaskList()	❌	❌ 需自建
模型降级	✅ fallbackModel()	❌	❌ 需自建
中间件管道	✅ middleware()	❌	❌ 需自建
文件系统工具	✅ 框架提供	✅ 框架提供	❌ 需手写
Checkpointer	JSON 文件	Redis	PG / Memory
Web 应用	Spring Boot 全套	agentscope.app.create_app	自建 FastAPI

3. 框架选型的真实感受

维度	HarnessAgent	AgentScope Python	LangGraph
上手难度	中（Builder 配置项多）	低（API 简洁）	最低（一行创建）
开箱能力	最强（计划/追踪/降级/中间件）	中（Agent + Toolkit）	最弱（仅 ReAct）
灵活性	中（框架约束较多）	中	最高（自由组合）
生产级能力	高（中间件管道 + 状态管理）	高（Redis + MessageBus）	中（需自建）
生态整合	Spring 生态	AgentScope 生态	LangChain 生态
适合场景	企业级 Java 项目	Python Agent 快速开发	研究和原型探索

🎓 学习价值

对于初中级开发者

✅ 通过三个项目的对比，理解 AI Coding Agent 的通用架构——不管用什么框架，核心组件（工具、提示词、会话、流式输出）是一样的
✅ 学习 ReAct 模式在不同框架中的实现——从 HarnessAgent 的内置循环到 LangGraph 的 create_react_agent
✅ 掌握 如何为大模型设计可调用工具——9+ 个工具的实现横跨 Java 和 Python
✅ 理解 SSE 流式推送的跨语言实现——Reactor Sinks vs FastAPI StreamingResponse vs astream_events

对于高级开发者

✅ 深入对比 AgentScope Java vs AgentScope Python vs LangGraph 的设计哲学差异
✅ 理解 会话持久化的三种策略——JSON 文件 / Redis / PostgreSQL 的适用场景
✅ 学习 中间件管道模式（Java 独有）vs 事件流模式（Python）的架构权衡
✅ 掌握 Skills 系统的跨语言设计——同一套 Markdown 文件在三种实现中通用

对于架构师

✅ 跨语言 Agent 架构设计的实战参考——验证"好设计是跨语言的"
✅ Agent 框架选型决策——从"开箱能力"到"灵活性"的完整权衡矩阵
✅ 工具系统分层设计——框架内置工具 vs 自定义工具的边界划分
✅ 前端共享策略——三种后端实现共享同一套前端静态文件的设计思路

🚦 快速开始

前置要求

JDK 17+（Java 版）
Python 3.10+（Python 版）
阿里云百炼 API Key（申请地址）

方式一：Java 版 (babi)

export DASHSCOPE_API_KEY=your_api_key

# Web 聊天界面
git clone https://github.com/javahongxi/babi.git
cd babi
mvn spring-boot:run -pl babi-agent
# 打开 http://localhost:8900

# CLI 模式
./install.sh
babi

方式二：AgentScope Python 版 (babi-agentscope)

export DASHSCOPE_API_KEY=your_api_key

git clone https://github.com/javahongxi/babi-agentscope.git
cd babi-agentscope
pip install -e ".[dev]"

# CLI 模式（默认当前目录为工作区）
babi-as

# Web 聊天界面（需要 Redis）
babi-as --web

方式三：LangGraph Python 版 (babi-langgraph)

export DASHSCOPE_API_KEY=your_api_key

git clone https://github.com/javahongxi/babi-langgraph.git
cd babi-langgraph
pip install -e ".[dev]"

# CLI 模式
babi-lg

# Web 聊天界面（可选 PostgreSQL 持久化）
export BABI_PG_DSN=postgresql://user:pass@localhost:5432/babi  # 可选
babi-lg --web

试试这些

# 代码分析
帮我看看当前项目的目录结构

# 构建执行
帮我编译这个项目

# 代码搜索
搜索所有包含 @RestController 的文件

# GitHub 操作
查看我的 GitHub 置顶仓库

# 联网搜索
搜索 AgentScope 的最新版本

# Skills 扩展
# 将 .md 文件放到 ~/.babi/skills/ 目录，三个版本自动加载同一份技能

🔗 相关链接

📦 babi (Java): https://github.com/javahongxi/babi
📦 babi-agentscope (Python): https://github.com/javahongxi/babi-agentscope
📦 babi-langgraph (Python): https://github.com/javahongxi/babi-langgraph
📖 AgentScope Java: https://github.com/agentscope-ai/agentscope-java
📖 AgentScope Python: https://github.com/modelscope/agentscope
📖 LangGraph: https://langchain-ai.github.io/langgraph/
📖 Spring Boot: https://spring.io/projects/spring-boot
📖 FastAPI: https://fastapi.tiangolo.com
☁️ 通义千问 (DashScope): https://dashscope.console.aliyun.com
📚 Java 全栈技术全景: whatsmars
☁️ Spring Cloud 微服务实战: spring-cloud-samples

📝 结语

从 Java 的 HarnessAgent Builder 到 Python 的 AgentScope Agent，再到 LangGraph 的 create_react_agent——三种实现走下来，最大的收获不是"哪个框架更好"，而是：好的 Agent 设计是跨语言的。

Skills 系统在 Java 和 Python 中几乎是一比一的翻译；系统提示词的核心规则（Tool-First、No Hallucination、No Self-Denial）在三个项目中逐字相同；SSE 事件类型（token / tool_call / tool_result / done）在前端完全一致——这些"不变的东西"，才是 AI Coding Agent 设计的精髓。

而差异同样有价值：HarnessAgent 的计划模式和中间件管道让你思考"Agent 还需要什么能力"；LangGraph 的极简 API 让你理解"ReAct 的核心其实很简单"；AgentScope Python 的 FunctionTool 让你看到"工具注册可以有多优雅"。

如果你正在：

🎯 想深入理解 AI Coding Agent 的架构设计，而不是停留在"调 API"
🚀 想在 Java 和 Python 之间做 Agent 框架选型，需要真实的对比参考
🏗️ 想搭建自己的 Coding Agent，需要一套跨语言的架构蓝图
🤖 想体验同一个 Agent 在三种框架下的表现差异

Star ⭐ 三个 Babi Agent 仓库，开启跨语言的 AI Coding Agent 探索之旅！

# Java 版
git clone https://github.com/javahongxi/babi.git

# AgentScope Python 版
git clone https://github.com/javahongxi/babi-agentscope.git

# LangGraph Python 版
git clone https://github.com/javahongxi/babi-langgraph.git

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

KMP全栈开发：从Android到AI Agent的技术演进与实践

总结 KMP 作为全栈开发核心纽带的价值。强调“全栈”思维从技术栈统一向“业务能力闭环”的演进。鼓励开发者拥抱 KMP，探索 AI 赋能的下一代应用开发。

AI Agent技术社区

rvs（rust-verb-shell）：一款面向人类和 AI Agent 的结构化 Shell

Rust-Verb-Shell（rvs）是一款基于Rust开发的创新型Shell工具，采用MulanPSL-2.0开源协议。其核心特性包括：1）严格遵循verb-noun语义命名规范（如get-child-item）；2）内置沙盒安全模式，可限制文件系统访问范围；3）双模输出（人类友好的表格格式和AI/脚本专用的JSON格式）；4）采用日历版本号（CalVer）YY.M.P格式。项目特别注重AI友