Unlock Autonomous AI Agents with Spring AI Alibaba: Scheduling & Real-World Cases

Introduction

Referencing LangChain’s article on ambient agents, the text explores two new agent execution models beyond the typical chat‑driven interaction: continuously running autonomous agents and agents that can proactively initiate human‑machine interaction.

Framework Support

Spring AI Alibaba (SAA) offers a dedicated framework that simplifies the development of these agent patterns, allowing businesses to implement the scenarios described below.

Why Autonomous Agents?

Autonomous agents break the limitation of requiring a user‑initiated conversation. By listening to environmental signals—such as timers, message events, or context changes—agents can execute planned tasks without human prompts, which is valuable in many real‑world workflows.

They also enable a balance between autonomy and controllability by providing a human‑in‑the‑loop window for tasks that need manual confirmation.

Business Impact

Individual entrepreneurs can dramatically expand their capability boundaries.

Engineering teams can replace multi‑person collaboration with a “one‑person + multiple agents” model, boosting productivity.

Explorable Scenarios

Automated Periodic Business : Scheduled agents collect, analyze, and visualize operational data, producing reports without human supervision.

Batch Settlement Processing : Parallel agents handle large‑scale financial data, news, and social media to uncover investment opportunities and risks.

Event‑Driven Emergency Response : Agents monitor IoT or security alerts, classify event severity, and issue appropriate notifications.

Human‑In‑The‑Loop Decision Making : Agents perform routine analysis and only involve humans when high‑risk situations arise.

Complex Long‑Cycle Tasks : Agents pre‑process multi‑modal data in the background, delivering finished results to users on demand.

Periodic Memory Management : Agents retain execution history across cycles, enabling trend analysis and intelligent routing of subsequent actions.

How to Build Timed Agents

Existing solutions fall into two categories:

Chat‑based task tools (e.g., ChatGPT Task, Manus Task) rely on prompt‑driven periodic reminders.

Low‑code platforms (e.g., Bailei, Coze, Dify) use external triggers and simple scheduling.

Graph‑based frameworks (e.g., LangGraph, Spring AI Alibaba) provide APIs for precise scheduling, high‑code flexibility, and integration with dedicated scheduling engines.

SAA Design Overview

SAA exposes a CompiledGraph.schedule(ScheduleConfig config) method to set an agent’s execution schedule. Registered agents are managed by ScheduledAgentManager, which currently offers a single‑process implementation but can be extended for distributed deployments.

Example: Store Daily Report Agent

@Bean
public CompiledGraph dailyReportAgent(ChatModel chatModel) throws GraphStateException {
    ChatClient chatClient = ChatClient.builder(chatModel)
        .defaultAdvisors(new SimpleLoggerAdvisor())
        .build();
    AsyncNodeAction dataLoaderNode = node_async((state) -> {
        /* Load order data, product info, customer feedback, etc. */
    });
    LlmNode llmDataAnalysisNode = LlmNode.builder()
        .chatClient(chatClient)
        .paramsKey("data_summary")
        .outputKey("summary_message_to_sender")
        .userPromptTemplate(DAILY_REPORT)
        .build();
    StateGraph stateGraph = new StateGraph("OperationAnalysisAgent", () -> {
        Map<String, KeyStrategy> strategies = new HashMap<>();
        strategies.put("data_summary", new ReplaceStrategy());
        strategies.put("summary_message_to_sender", new ReplaceStrategy());
        strategies.put("message_sender_result", new ReplaceStrategy());
        strategies.put("access_token", new ReplaceStrategy());
        return strategies;
    })
        .addNode("data_loader", dataLoaderNode)
        .addNode("data_analysis", node_async(llmDataAnalysisNode))
        .addNode("message_sender", node_async(generateMessageSender()))
        .addEdge(START, "data_loader")
        .addEdge("data_loader", "data_analysis")
        .addEdge("data_analysis", "message_sender")
        .addEdge("message_sender", END);
    CompiledGraph compiledGraph = stateGraph.compile();
    compiledGraph.setMaxIterations(100);
    ScheduleConfig scheduleConfig = ScheduleConfig.builder()
        .cronExpression("0 0 8 */1 * ?") // every day at 8 AM
        .build();
    compiledGraph.schedule(scheduleConfig);
    return compiledGraph;
}

Example: Evaluation Sentiment Analysis Agent

@Bean
public CompiledGraph evaluationAnalysisAgent(ChatModel chatModel, FeedbackMapper feedbackMapper) throws GraphStateException {
    ChatClient chatClient = ChatClient.builder(chatModel)
        .defaultAdvisors(new SimpleLoggerAdvisor())
        .build();
    EvaluationClassifierNode sessionAnalysis = EvaluationClassifierNode.builder()
        .chatClient(chatClient)
        .inputTextKey("iterator_item")
        .outputKey("session_analysis_result")
        .categories(List.of("yes", "no"))
        .classificationInstructions(List.of(
            "Return pure JSON with fields: user, time, complaint, satisfaction, summary.",
            "complaint: yes/no indicating a complaint.",
            "satisfaction: actual user satisfaction level.",
            "summary: core complaint point and improvement suggestion"))
        .build();
    StateGraph sessionAnalysisGraph = new StateGraph("session_analysis", subFactory1)
        .addNode("iterator", node_async(sessionAnalysis))
        .addEdge(StateGraph.START, "iterator")
        .addEdge("iterator", StateGraph.END);
    AsyncNodeAction sessionLoaderNode = node_async(state -> {
        // Load sentiment and review data
        return result;
    });
    AsyncNodeAction sessionResultSummaryNode = node_async(state -> {
        // Summarize analysis results
        return Map.of();
    });
    LlmNode llmNode = LlmNode.builder()
        .chatClient(chatClient)
        .paramsKey("summary_message")
        .outputKey("summary_message_to_sender")
        .systemPromptTemplate("Custom Prompt")
        .build();
    StateGraph stateGraph = new StateGraph("ReviewAnalysisAgent", () -> {
        Map<String, KeyStrategy> strategies = new HashMap<>();
        // define strategies ...
        return strategies;
    })
        .addNode("session_loader_node", sessionLoaderNode)
        .addNode("iteration_session_analysis_node", iterationNode)
        .addNode("session_result_summary_node", sessionResultSummaryNode)
        .addNode("message_parse", node_async(llmNode))
        .addNode("message_sender", node_async(generateMessageSender()))
        .addNode("human_feedback", node_async(new HumanFeedbackNode()))
        .addNode("human_action", node_async(new HumanActionNode()))
        .addEdge(START, "session_loader_node")
        .addEdge("session_loader_node", "iteration_session_analysis_node")
        .addEdge("iteration_session_analysis_node", "session_result_summary_node")
        .addConditionalEdges("session_result_summary_node", AsyncEdgeAction.edge_async(state -> {
            Integer complaint = state.value("complaint", 0);
            return complaint > 0 ? "message_parse" : StateGraph.END;
        }), Map.of("message_parse", "message_parse", StateGraph.END, StateGraph.END))
        .addEdge("message_parse", "message_sender")
        .addEdge("message_sender", "human_feedback")
        .addConditionalEdges("human_feedback", AsyncEdgeAction.edge_async(state -> {
            boolean ignore = state.value("ignore", true);
            return ignore ? StateGraph.END : "human_action";
        }), Map.of("human_action", "human_action", StateGraph.END, StateGraph.END))
        .addEdge("message_sender", END);
    CompiledGraph compiledGraph = stateGraph.compile();
    compiledGraph.setMaxIterations(1000);
    ScheduleConfig scheduleConfig = ScheduleConfig.builder()
        .cronExpression("0 0 */1 * * ?") // every hour
        .build();
    compiledGraph.schedule(scheduleConfig);
    return compiledGraph;
}

Conclusion

Autonomous AI agents expand enterprise intelligence by combining timed triggers, event‑driven responses, and human collaboration, delivering efficient and precise automation. With Spring AI Alibaba, developers can rapidly create customized agents that cover the full pipeline from data acquisition to decision‑making.