[DEVOXXBE] From AI to Agent: A Field Guide to Agentic Patterns in LangChain4j

You have already built AI features into your Java application. The model is wrapped in a service, RAG feeds it context, tools are wired, calls are flowing. It works. Then requirements evolve. A single prompt-and-response is no longer enough. You need steps that follow each other, branches based on decisions, retries when things fail, sometimes several actions at once. The question shifts from "how do I call an LLM?" to "how do I keep it under control?".

That is where agentic systems come in. In three hours we start with a single @Agent doing one job and grow it live into a multi-agent system that can analyze, plan, act, and report back. Each step starts naive. We run it, feel the cracks, then reach for the pattern that holds: sequential, loop, parallel, and conditional workflows. AgenticScope and typed keys keep shared state honest. Goal-oriented agents, an LLM-driven supervisor, and a custom Planner take over when a fixed pipeline stops being enough. We add non-AI agents for deterministic work, human-in-the-loop checkpoints before external actions, and observability with the AgentMonitor, because an agent you cannot see is an agent you cannot debug.

You will leave able to look at a problem and tell whether it wants a plain workflow or a real agent, and how much autonomy to hand over before you lose the thread. The goal is not smarter prompts. It is agentic systems easier to reason about and evolve, because the pattern you do not adopt is the one you do not have to debug.

Transcript

1. From AI to Agent: A Field Guide to Agentic Patterns in LangChain4j @LoMagnette
2. Loïc Magnette @LoMagnette lomagnette.github.io
3. Back to basic
4. AI Service @LoMagnette
5. AI Service @UserMessage(""" Turn this message into a sitter card with exactly these five lines. Invent nothing — if the message does not say, write "not given": Dog: Meals: Walks: Watch out for: Vet: Message: {{message}}""") String card(@V("message") String message); @LoMagnette
6. AI Service var aiService = AiServices.builder(NoteRetriever.class) .chatModel(model) .build(); var notes = aiService.card(input); @LoMagnette
7. Demo
8. Agent @LoMagnette
9. Agent An agent is a service that talk to an AI model to perform a goalbased operation using the tools and context it has. @LoMagnette
10. Agent @Agent(description = "Turns a rambling message about the dog into a structured sitter card") @UserMessage(""" Turn this message into a sitter card with exactly these five lines. Invent nothing — if the message does not say, write "not given": Dog: Meals: Walks: Watch out for: Vet: Message: {{message}}""") String card(@V("message") String message); @LoMagnette
11. Agent var clerk = AgenticServices.agentBuilder(SitterCardClerk.class) .chatModel(model) .name("SitterCardClerk") .outputKey("Notes") .build(); @LoMagnette
12. State Management @LoMagnette
13. State Management @LoMagnette
14. State Management @LoMagnette
15. State Management Agentic Scope @LoMagnette
16. @LoMagnette
17. Workflow Workflow @LoMagnette
18. Sequence @LoMagnette
19. Sequence @LoMagnette
20. Sequence Use cases • Multi-source research • Independent analyses • Generating several alternatives @LoMagnette
21. Sequence Cons • Rigid execution order • Potentially unnecessary work • Failure propagation @LoMagnette
22. Loop @LoMagnette
23. Loop @LoMagnette
24. Loop Use cases • Content refinement • Code improvement • Plan optimization @LoMagnette
25. Loop Cons • Difficult exit condition • High cost • No guaranteed improvement @LoMagnette
26. Parallel @LoMagnette
27. Parallel @LoMagnette
28. Parallel Use cases • Independent expert reviews • multi-source research • complementary recommendations @LoMagnette
29. Parallel Cons • Branches must be independent • write conflicts • waits for slowest @LoMagnette
30. Parallel mapper @LoMagnette
31. Parallel mapper Use cases • Batch classification • Batch summarization • Personalization @LoMagnette
32. Parallel mapper Cons • Items must be independent • large batches are expensive • no ChatMemory @LoMagnette
33. Routing @LoMagnette
34. Routing Police Herding Speed @LoMagnette
35. Routing Use cases • Expert routing • Risk routing • Format/language routing @LoMagnette
36. Routing Cons • Depends on routing state • Zero or multiple matches • Incompatible branch outputs @LoMagnette
37. Typed key @LoMagnette
38. Typed key public record Checklist() implements TypedKey<String>{} var list = AgenticServices.agentBuilder(FridgeChecklist.class) .chatModel(model) .name("FridgeChecklist") .outputKey(Checklist.class) .build();
39. Human in the loop @LoMagnette
40. Human in the loop @LoMagnette
41. Error handling @LoMagnette
42. Non AI-Agent @LoMagnette
43. Observability / Monitoring @LoMagnette
44. Dynamic model @LoMagnette
45. Agentic @LoMagnette
46. Supervisor @LoMagnette
47. Supervisor @LoMagnette
48. Supervisor @LoMagnette
49. Supervisor @LoMagnette
50. Supervisor @LoMagnette
51. Supervisor @LoMagnette
52. Supervisor @LoMagnette
53. Supervisor Use cases • Customer-support orchestration • Dynamic tool orchestration • Open-ended assistant tasks @LoMagnette
54. Supervisor Cons • Nondeterministic planning • Strong dependence on model quality • Cost and safety risks @LoMagnette
55. Goal Oriented @LoMagnette
56. StateOriented Goal Pre-conditions Post-conditions @LoMagnette
57. StateOriented Goal @LoMagnette
58. StateOriented Goal Agentic Scope @LoMagnette
59. StateOriented Goal Agentic Scope @LoMagnette
60. StateOriented Goal Agentic Scope @LoMagnette
61. Goal Oriented Use cases • Adaptive document processing • Data-enrichment workflows • Deterministic tool pipelines @LoMagnette
62. Goal Oriented Cons • Keys do not express semantic quality • Shortest does not mean best • Limited runtime adaptation @LoMagnette
63. Peer to peer @LoMagnette
64. Stateto peer Peer @LoMagnette
65. Stateto peer Peer Required input @LoMagnette
66. Stateto peer Peer Agentic scope @LoMagnette
67. Stateto peer Peer Agentic scope @LoMagnette
68. Stateto peer Peer Agentic scope @LoMagnette
69. Peer to peer Use cases • Collaborative research • Reactive data enrichment • Emergent multi-expert problem-solving @LoMagnette
70. Peer to peer Cons • Cycles and invocation explosions • Concurrent write conflicts • Unpredictable execution and cost @LoMagnette
71. Blackboard @LoMagnette
72. State Blackboard Agentic scope @LoMagnette
73. Blackboard
74. Blackboard
75. State Blackboard Agentic scope @LoMagnette
76. State Blackboard Agentic scope @LoMagnette
77. Blackboard Use cases • Technical diagnosis • Incident response • Constraint-solving workflows
78. Blackboard Cons • The strategy becomes a bottleneck • Sequential execution can be slower • Stable state does not guarantee success
79. Voting @LoMagnette
80. Voting @LoMagnette
81. Voting @LoMagnette
82. Voting Use cases • Classification and categorization • Risk assessment • Candidate selection @LoMagnette
83. Voting Cons • Correlated errors • Aggregation problems • Higher cost without guaranteed improvement @LoMagnette
84. Debate
85. State Debate @LoMagnette
86. State Debate Debaters @LoMagnette
87. State Debate Debaters Judge @LoMagnette
88. State Debate @LoMagnette
89. State Debate @LoMagnette
90. State Debate @LoMagnette
91. State Debate @LoMagnette
92. State Debate @LoMagnette
93. State Debate @LoMagnette
94. Debate Use cases • Risk analysis • Architecture decisions • Investment analysis
95. Debate Cons • High cost and latency • Agreement does not guarantee truth • Convergence remain difficult
97. Desire Belief Intention @LoMagnette
98. Desire Belief Intention Beliefs Agentic Scope @LoMagnette
99. Desire Belief Intention Desire Activation @LoMagnette
100. Desire Belief Intention Desire Activation Completion @LoMagnette
101. Desire Belief Intention Desire Priority Activation Completion @LoMagnette
102. Desire Belief Intention Intention @LoMagnette
103. Desire Belief Intention Beliefs Achievable Desires Desires @LoMagnette
104. Desire Belief Intention Achievable Desires Highest priority Desire @LoMagnette
105. Desire Belief Intention Highest priority Desire Select current intention Beliefs @LoMagnette
106. Desire Belief Intention Done Beliefs Look for achievable desire @LoMagnette
107. Desire Belief Intention Desire Desire Desire Desire Beliefs Desires Desire #3 @LoMagnette
108. Desire Belief Intention Desire Desire Desire Done Beliefs Desires Desire #3 @LoMagnette
109. Desire Belief Intention Desire Desire Desire Done Beliefs Desires Desire #1 @LoMagnette
110. Desire Belief Intention Use cases • Autonomous operational response • Robotics or game characters • Business or portfolio management @LoMagnette
111. Desire Belief Intention Cons • Complex desire design • Plans are predefined • Starvation and preemption complexity @LoMagnette
112. Custom Pattern @LoMagnette
113. Combining solution
114. Where to start WORKFLOW GOAP, P2P, Voting,… SUPERVISOR Control High Medium Low (LLM) Flexibility Low Medium-High High Cost Low Medium High Auditability Excellent Good Difficult Best for Stable pipeline Variable deps Adaptive systems Deterministic Autonomous Start here @LoMagnette
115. Where to start “the pattern you do not adopt is the one you do not have to debug” @LoMagnette
116. @LoMagnette
117. RESOURCES @LoMagnette lomagnette.github.io @LoMagnette
118. FEEDBACK @LoMagnette lomagnette.github.io @LoMagnette