所有 AI 编程 Agent 共享同一个循环：调用模型、执行工具、回传结果。生产级系统会在其上叠加策略、权限和生命周期层。

python

while True:
    response = client.messages.create(messages=messages, tools=tools)
    if response.stop_reason != "tool_use":
        break
    for tool_call in response.content:
        result = execute_tool(tool_call.name, tool_call.input)
        messages.append(result)

这段代码人工翻译一下就是：

1. 调模型（给指令）
2. 执行工具（读写文件、跑命令）
3. 回传结果（告诉模型干了啥）
4. 继续迭代（直到任务干完）

就这？就这。剩下的全是围绕这个循环的各种优化和补丁。

用 Java 来写，核心循环大概是这样：

java

while (true) {  
    MessageResponse response = client.messagesCreate(messages, tools);  
    if (!"tool_use".equals(response.getStopReason())) {  
        break;  
    }  
    for (ToolCall toolCall : response.getContent()) {  
        ToolResult result = executeTool(toolCall.getName(), toolCall.getInput());  
        messages.add(result);  
    }  
}

正是考虑到我们的读者多数是Java同学，因此我决定用Java来和大家一块学习下

渐进式学习路径

网站将这 12 个阶段（s01-s12）归纳为五个核心能力的进阶，看看一个成熟的 Agent 系统是如何一步步被做出来的：

S01 Agent 循环

最小可用的 Agent 内核仅仅需要：一个 while 循环 + 一个工具。

说白了就是Agent 最本质的“大脑-手脚”循环

Java实现代码

java

public class AgentLoop {

    // 模拟 Anthropic API 客户端
    private static final String API_KEY = System.getenv("ANTHROPIC_API_KEY");
    private static final String MODEL_ID = System.getenv("MODEL_ID");
    private static final HttpClient client = HttpClient.newHttpClient();

    // 核心循环
    public static void agentLoop(List<Map<String, Object>> messages) {
        while (true) {
            // 1. 调用 LLM
            System.out.println(">>> 正在思考...");
            Map<String, Object> response = callLLM(messages);
            
            // 2. 将助手回复加入历史
            messages.add(response);

            // 3. 检查停止原因
            // 注意：这里简化了逻辑，实际需解析 JSON 中的 stop_reason
            String stopReason = (String) response.get("stop_reason");
            
            if (!"tool_use".equals(stopReason)) {
                return; // 任务完成，退出循环
            }

            // 4. 执行工具
            List<Map<String, Object>> toolResults = new ArrayList<>();
            List<Map<String, Object>> content = (List<Map<String, Object>>) response.get("content");
            
            for (Map<String, Object> block : content) {
                if ("tool_use".equals(block.get("type"))) {
                    Map<String, Object> input = (Map<String, Object>) block.get("input");
                    String command = (String) input.get("command");
                    String toolId = (String) block.get("id");

                    System.out.println("\033[33m$ " + command + "\033[0m"); // 黄色输出命令
                    
                    // 执行 Bash
                    String output = runBash(command);
                    System.out.println(output.length() > 200 ? output.substring(0, 200) + "..." : output);

                    // 构造工具结果
                    Map<String, Object> result = new HashMap<>();
                    result.put("type", "tool_result");
                    result.put("tool_use_id", toolId);
                    result.put("content", output);
                    toolResults.add(result);
                }
            }

            // 5. 将工具结果作为用户输入再次加入历史
            Map<String, Object> userTurn = new HashMap<>();
            userTurn.put("role", "user");
            userTurn.put("content", toolResults);
            messages.add(userTurn);
        }
    }

    // 模拟 LLM 调用 (实际需替换为 SDK 调用)
    private static Map<String, Object> callLLM(List<Map<String, Object>> messages) {
        // 这里是一个占位符，实际应发送 HTTP 请求给 Anthropic API
        // 返回结构需匹配 API 响应
        return new HashMap<>(); 
    }

    // 执行 Shell 命令
    private static String runBash(String command) {
        // 安全检查
        if (command.contains("rm -rf /") || command.contains("sudo")) {
            return "Error: Dangerous command blocked";
        }

        try {
            ProcessBuilder pb = new ProcessBuilder("bash", "-c", command);
            pb.redirectErrorStream(true);
            Process p = pb.start();

            // 读取输出
            BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
            StringBuilder output = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                output.append(line).append("\n");
            }

            // 等待完成 (带超时)
            if (!p.waitFor(120, TimeUnit.SECONDS)) {
                p.destroyForcibly();
                return "Error: Timeout (120s)";
            }

            String result = output.toString().trim();
            return result.isEmpty() ? "(no output)" : result.substring(0, Math.min(result.length(), 50000));

        } catch (IOException | InterruptedException e) {
            return "Error: " + e.getMessage();
        }
    }

    public static void main(String[] args) {
        List<Map<String, Object>> history = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);

        System.out.println("Agent 已启动 (输入 'q' 退出)");

        while (true) {
            System.out.print("\033[36ms01 >> \033[0m");
            String query = scanner.nextLine();

            if (query.trim().equalsIgnoreCase("q") || query.isEmpty()) {
                break;
            }

            Map<String, Object> userMsg = new HashMap<>();
            userMsg.put("role", "user");
            userMsg.put("content", query);
            history.add(userMsg);

            agentLoop(history);
            
            // 打印最终回复
            System.out.println("Agent 执行完毕。");
        }
    }
}

这段代码包含了所有 AI Agent 的灵魂。

核心模式：ReAct 循环