Intelligent Java Apps: Agent Patterns, MCP, and the Future of AI-Native Design - Daniel Oh

This talk discusses the evolution of agentic AI, highlighting the shift from traditional generative AI to more autonomous agentic systems. The speaker, Daniel from Red Hat and IBM, emphasizes the use of Java in building these systems and explains various design patterns essential for developing agentic AI, including sequence, parallel, and supervisory patterns. He outlines how multi-agent systems can replace certain business workflows, enhancing efficiency and autonomy in tasks. Furthermore, the talk covers the importance of integration tools like the MCP protocol, the need for observability in AI applications, and the developer's changing role toward orchestration and system design in AI projects.

So today I'm going to tell a little bit about uh like a agentic AI over course we using Java. And then a bunch of the agentic AI design pattern and how do you you actually put it together and the build new agentic system. So my name is Daniel. I'm from Red Hat but also IBM because all Java people actually moved to IBM. I'm a global uh developer

team specialized Java and like a AI get out security serverless. And here's a bunch of other my uh community contribution like a Java champion and among others. And if you have any question about me and about this session right after this talk and if you feel free to reach out to me and you can actually Google me and or the my all social media handle are Daniel

or 30. So there are many Daniel around the world. So I end up with uh number 30. So I'm living in a Boston. It's a long flight from Boston and Bangalore. So uh let's try to uh take a one step back and try to understand. So you probably uh heard about and you used AI stuff uh like a Open AI uh launched the ChatGPT almost 3 and

1/2 years ago. At the time there are very simple AI application which is the most like a chatbot. And the Google Gemini Oops. What happened? I didn't do anything. Okay. So at the time is a simple chatbot like a Google Gemini or Open AI ChatGPT. You can ask whatever you want like a some simple question. Who is a Daniel and then uh where he lives and then

you can ask any kind of question any universal random general question. And in order to design and develop their simple AI application at the time, as a developer, you just write a code using Java, Python, whatever you want. And then like a simple UI, and then like a some simple prompt engineering like a zero-shot, multi-shot, chain of thought. Pretty much a simple. And system design for AI

application is so very like a simple, like a more imperative. And then you can actually give some instruction for AI model, like a some couple of a point and a numbers, and then you're going to go this way, that way. That is the like a more generative AI at a time. Doesn't matter generate image, text, or code, whatever you want. And the things have changed there. Like

a one year happier ago, Anthropic released uh MCP. And then now people talk about agent AI. Nobody talked about anymore a generative AI anymore. It's agent AI, as you know, it's autonomous capability. Whatever you do, you don't need to give some detailed instruction. Because of previous gen AI, you probably treated with AI model like a 5-year-old daughter. Hey, you need to do, sweetheart, ABC, XYZ. But you

don't need to do anymore. Your agent AI, you can just give you your final goal. Hey, I need to go to fancy restaurant to eat local super spicy Indian curry. That's it. And then they try to find out and then give you best store near your hotel or your place. With the based on like a Google rates and like a some how far from your hotel. So

things have changed that and then And that is a more like a autonomously interacting your AI model. Not only one model, many models. And to system design changing a lot like a since the deep sea are two happened. So previously, whenever you got some wrong answer like a hallucination also known as and then what what did you do? You actually ask your fantastic smarter problem engineer or

AI engineer, "Hey, make him smarter." That is a fine-tuning alignment tuning or training model. Teach them, "Hey, you need to understand this business domain." That is how you make that happen. And the deep seek R2 are wrong. They changed the methodology. Okay, what about the way we let AI model spend more time think, act, and observe. That is your best chance. Just like a Google technical interview.

That is your best answer. What is the other optimization kind of thing? So, that is a like a reasoning platform. Now, AI model every AI model like a Gemini or other model based on reasoning platform AI And then developer changes role. Uh in this sort of a keynote, the keynote speaker actually knew developer role is like a coder to like a system like a designer kind of

thing. I don't totally agree with that. So, so previously you probably write a code uh regardless of uh using AI code assistant tool like a cursor cloud or copilot or IBM bar whatever you taste, you can actually write a code. And now you have a multi agents today. Multi agents can be replaced with your any business workflow. Even your like a company org. So, you have like

a supervisor and then their team members. One of the team member primary job can be replaced with agent AI. And then developer still need to managing that multi agent. That is a more like a orchestrating role. Okay, every single agent like a I really loved to the Marvel movie like a Tony Stark. He has own agent which is a Jarvis and change to Friday. So, basically uh

you have your own agent, maybe open claw today. So, each agent has their own priority and task. And the other agent has own task and priority for your business functionality. And then when you manage a multi-agent to build agentic system, how to orchestrate the multi-agents' job priority or task priority? That is you probably need to orchestrator or supervisor or in the loop, whatever you call that. Someone

actually designed the multi-agentic system. That is a new skill and responsibility of developer. Doesn't matter Java, .NET, Python, whatever you use that. So, that is a new paradigm. And why is Java still matters? Because Java was born 30 years ago. At a time, three decades, Java actually gave us a great evidence how to stand up your enterprise complex business application. So, when you design business complex application,

Python maybe not super good because of Python more like a prototype and make it easier for fine-tune fine-tuning or fine-tuning, something like that. But imagine that communicate a database messaging broker or third-party application, how do you actually put on the like a database capability in the Python? You can put on the Jupiter notebook, maybe 10,000 line of code. And then if we even that works, how do

you troubleshoot when you find the error? And Java is a very originally designed for database complexity. And like you can find some error during the compilation like a build time or run time. And then good performance library and the multi-threading, high concurrency for reactive application. And then more important thing is when you deploy application in production, and platform engineer or DevOps engineer, they can good observability like

a great giant to Of course, their problem engineer they change job more evolving using not that was more AI ops. And they will have their own personal assistant which is a digital SRE for agent AI too. Well, this is all Java actually great performance for enterprise application and AI as well. So, when you start new AI project like a agent AI project, let's say that. And then

you probably first day you have one AI model and the one tool and one agent AI. Which is very good, simple. You can just connect to AI model and sometimes AI model connect to tool like a function calling because AI model cannot know everything on your business application, business and services. So, that's why you need to call tool which allow to access the database or messaging broker

or any local file system for your business And what what happens 6 months later? And you have a many developer team. And each single individual developer they created their own agent connect to AI model and connect to tools. And then 6 months later you have like a hundred developer. They actually great job separately, individually. And now you a number of a models, number of a tools. And

then n square problem just like some messy here. But also you have maybe text I'm going to Python, I'm going to Java. And specifically like a Spring AI or LangChain for J or Quarkus or Micronaut or Helidon, whatever you want based on your skill set and knowledge. And then each each like a technical stack for agent AI app there probably different life cycle to release a capability

in both ways and performance and security issue. Indeed, 6 months later, this going to be make us some huge technical debt. And then crisis of this integration as well. That's the reason why you heard about a lot MCP model context protocol. But here's thing, the MCP is just transport layer between intelligence layer, which is the most likely your AI models. And the other side is a real

resources. Like a tool, data, file, something like that. with MCP, so people maybe misunderstand sometimes. Okay, we're going to go to create a new agent AI. Doesn't matter language or language agnostic way. And then what kind of technology we need to use for building agent AI? Everybody said MCP. That's probably true, but not always. So, MCP allow you like a red AI model and agent AI more

autonomous capability. But sometimes it takes more resources. Like a much more token. For example, you just spend 50 token when you start up, like a connect to AI model and then ask some question, who is Daniel O? But when you using MCP, you have agent AI application and MCP client and MCP server. And then finally your AI model and There are more network latency and more like

a resources to stand the MCP client server and token as well. So, sometimes you need to spend more than like a 5,000 token even before you ask first But developer actually doesn't much care about that. Because I just only focus on developing agent AI, make it work all the time, no hallucination, and more autonomous capability. That's great. And then when you just a push and commit your

code and they're using fantastic CICD and then you deploy AI application to the production, and then two days later and then your problem may engineer pissed off and then you spend a lot of token. We just out of token anymore. Nobody can use agent AI for the Java stuff, the MCP uh basically provide an agnostic language agnostic method. So, for the Java there are only SDK and

SDK actually three layers. One is the application, which is your agent AI, and the system layer and managing your status for like a request response. And the last thing is the most important layer, which is a transport using JSON RPC. And then here's thing. So, when you everything is fine and it's good, but when you fail with the MCP architecture and then it's a really hard to

troubleshoot. You can also ask another AI to, "Hey, what is the problem? Fix that thing right now." Maybe you can do that, but as developer at the agent AI system designer or orchestrator, you need to understand what root cause is. And then you don't know this is the problem MCP client or agent AI or MCP server or actual JSON RPC transport or AI model or It's a

really hard to uh find out and troubleshoot that. And then MCP transport layer, you can actually basically two things like a standard IO, which is a uh some kind of Java framework or you can actually run MCP server locally along with the your agent AI application as separate process. So, when you go to entropy GitHub and you can find MCP server today more than 5,000. And then,

most MCP server give some readme file, how to run this MCP server my local machine, which is running on NPM packaging. Because NPM packaging, you don't need to rely on some specific operating system. You can run it on and make OS, Linux, and Windows, among others. That is a standard IO. But, in some case, you are other team, they already build on MCP server, custom MCP server,

and then export it like a URL, just like a REST API. And you can just connect to that MCP server using like a SSE, or HTTP, or like a streamable HTTP kind of stuff. So, what about the Java developer? Okay, this kind of I understand. How do I actually run MCP server? I mean, in a more like a report to MCP server. And then, most Java developer

really love to use the correct API, which is annotation. So, there are Spring AI, and then LangChain4j most likely Quarkus LangChain4j integration. So, some people ask me, "Hey Dan, can I use just pure LangChain4j as open source?" Of course, you can do that. And why would I use Quarkus LangChain4j integration? Because the Quarkus primarily goal is to accelerate developer productivity, which means less code, make it better.

So, if you go to LangChain4j for MCP, or like a AI application, you can do like a two annotation, for example, on the meta level, and three line of configuration on your properties. And then, when you do the same feature in a Quarkus LangChain4j integration, one annotation and one configuration, even no configuration. So, in the behind the scene, Quarkus automatically auto wire everything is out of box

feature. So, give some more free time developer, and then make them focusing more on the more creative application development stuff. So, you could see that a AI. Spring also provide Spring AI for agent AI, but also Spring LangChain4j integration as well. But, uh basically open native framework. So, Spring XYZ is a known way Spring reactive, Spring native, Spring integration, Spring Cloud, Spring AI. Same way, same practices,

and the same ecosystem. And then using MCP 2 annotation on Spring AI and MCP 2 program, which is like a pass down your JSON as a meta rebel into your uh MCP 2 and end up with the your AI model. It's uh extraordinary uh reduce the uh boiler plate the source code, but also Quarkus uh you can just one annotation MCP 2 box, and the other all

thing is to make it happen using Quarkus framework. So, and then here's a very interesting definition of a terminology. Entropy, when they release MCP protocol uh like a 1 and 1/2 year ago, so they said people like actually mislead and misunderstand between workflow and agents. So, what is it actually agent means? And then oh, agent is gives some autonomous thing. You don't need to give some detailed

instruction to the model. You just to give some final goal, and then empty your agent your AI application autonomously and automatically figure it out what is the best answer for you. That is your agent. If you like a design sort of a business logic like like a you go left hand side, like a go to ABC, and then like a if else for loop just like a

your general business application, that is a workflow, not agent AI because you still give some guide instruction. And the things changed there. But, at the time 1 and 1/2 year ago, they said, "Oh, there are agent AI. This is a workflow." So, as long as you design like a this like a flow, that is not agent, like a more like a one of your general AI services.

And then 1 year later, a lot of people actually using and developing agent. And then, that means there's not only one agent. There are many agents, multi-agent. Not one, maybe 100, 10,000 agents. And the problem is it came up, "How do we manage these multi-agents?" That's why we need to workflow, back to the workflow. And now they changed the like a definition, okay, "Agent, same thing. And

workflow is actually a device design when you build agentic system." So, now workflow is more like advanced agentic pattern, design pattern to build So, here's the fundamental five agentic patterns. We can probably have more, but most likely you can actually combine this one. I'm not saying you're going to pick one of them. You can actually use one of them, you can use three of them, you can

use all of them based on uh your agentic system. So, you could you could just instantly understand this whole pattern because of pretty much like a application business logic. So, sequence, first agent call second agent, second agent call third agent. But here thing is like a second agent input first agent output. And then, parallel is a basically like a concurrently uh running on multi-agent at the same

time. And routing is a basically like a if-else condition. And looping like a for stuff. And the supervisor is a very important thing. So, you could have a multi-agents, and then some of the agents actually supervise the other agents. Like a "Oh, you're going to go first. Or you're going to go to later." That's a supervisor. Like you can say orchestrator, supervisor. Just like a your team

organization. Oh, there are supervisor or a boss, just like that. And supervisor thing. And the goal-oriented design, so now you don't need to give us some instruction detail anymore. You can actually write down more like a like a 200 right now with like a system necessity for initialize your AI model, but all but instead of that you can give us some more like a shortest path or

like a goal definition. Just like a what is a my ultimate and final goal? And then it invoke and trigger your like a supervisor agent for example. And supervisor agent actually uh give you some delegate some job for each sub agents. And then that actually uh communicate with the your reasoning AI platform and try to find out best path get your and achieve your goal. Of course,

the first time you're going to ask some very new goal, maybe it takes longer, uh but second chance or third chance is a uh super fast uh but the first time. And then agent can be fail. It's not uh it could be possible. And then it's not weird. It's probably very normal. AI anytime can fail. And but you're not going to give us a 100% autonomous capability

to your agent to decide whatever they say. Something like a mission critical decision, you cannot do that. Even you using open code today, maybe you can put in the your all credential like a your bank account or some of the stuff and then or even stock market. Okay, and then my agent is super smart and he find out I'm going to buy this stock today. And then

but you know what? So, and then 2 months later and then your money is all gone. So, anytime can fail. So, that's the why you put in the like a put the reliability, you put in the some kind of judging API like a between uh AI is a non-deterministic. And then you still develop application agent AI application, as deterministic way. So, you can bridge between non-deterministic and

deterministic using like a judge API. Judge API could be your like a some simple application based on like a if else, something like that. Or you can actually put on the actual human in the loop. So, you could decide by human, not AI. Or you could actually let another AI model decide the end result. Like a for security, for performance, or some major decision call. That is

a judge API. And of course, agent AI, they need to manage their status and like a three different type of like a status. First thing is like a pretty much more like a short-term uh session memory. So, you don't you don't want let your agent AI's uh become like a dumb idiot because uh you don't want to ask the same goal over and over again. So, when

you ask some second goal, pretty much it rate first goal. So, that's the one to keep uh memorize the system memory. Or sometimes you got to maybe long-term uh memory could be stored in the vector store rather than session memory. And the last thing is like your personal like a preferences for whatever you ask because my most question about like the schools or some Java technology, you

don't need uh explicitly highlight on the Java technology whenever you ask a question. At the time, you can put in the that personal information or persistent uh like a preferences in the like a external like a more like a database, something like a PostgreSQL, something like that. So, we talked about that we learned about that how do you manage uh design agentic system with a multi-design pattern.

And specifically, each design pattern maybe can be connecting to external tool using MCP. So, what about they actually communicate the multi-agent each other like a so between them. So, and then so Google actually made this one like a agent to agent like a A2A, which is a more discrete like a agentic system. The great thing is you can actually stand out language agnostic. So, team A they

prefer Python, team B JavaScript, team C Java. And then the the A2A actually language agnostic and then each developer team they don't need to rely on other team like a product release or product schedule. So, they just keep you focus on your remote agent and then your own agent is a this is a more like a standard way and language agnostic. And then as a developer standpoint,

okay, how do we uh discover the external agent on my discrete agentic system? Basically, you need to define and create agent.json file. That JSON file include uh agent agent's identity, capability, skill set, and technical requirement and exposed with this well-known like a like a URL path something like a uh {slash}well-known{slash}agent.json. This is a more like a you can actually define whatever you want, but you have to

uh share this URL and JSON schema with your other team. So, that is how to do that. And then for example, I'm going to show Quarkus and then Quarkus uh uh doesn't doesn't need it to create the manually the JSON file. So, you could actually create a simple Java method and it automatically create JSON internally and expose that URL. So, that is a more convenient way for

like a Java developer as well. And anyway, they also managing their like a process. So, when you actually agent anyway, they have a two different like a task. One is a like a simple chatbot and the other is a more long-term task. Because when you call the external agent specialized specific job and you probably waiting for the response from that. It not going to maybe take so

like a like a half a second. It more take some more like a couple second or even more than that. So, that's why more long-term stable like a task processing between client agent and remote agent as all. And the product security, when you deploy this A2A or multi-agent system in production, and you always think about security. So, people a lot of said specifically devsecops people, you can

shift to your security matter as much as a possibly from right to left. The left means developers. So, developer they whenever they create a new agent AI application, they don't they should not expose like a some your local or some sensitive information exposing like A2A stuff. So, that should be like a black box. And then you only expose like a URL and agent skill set. And so,

let's jump into the demo. So, here's my like a little bit like a demo system. So, this is a like a like a like a rental car system. So, in a rental car system, they actually have a many workflow. So, when you rent a car and then in an app they use the car and then return the vehicle. And then you can just leave the car and

then just left. And someone actually from the rental car company like a Hertz, Avis, they actually try to check the vehicle. Is there a dolly or is there there is some damages, some fender or some stuff inside the exterior or more others. And then when they find that some like a status or condition of the and they give us some feedback and then that based on feedback

they can actually call to some other department like a maintenance department. They're going to try to repair some damage or cleaning department. They actually try to clean a car or they actually do the same thing in the first repair and the cleaning car or and then back to the inventory and the ready to render render car again. So that kind of actually happened. And then that always

just done by human being. And now they okay, we need to use AI like agent AI. So we're going to try to make a auto autonomously and automatically replace the most likely kind of thing with the So here there's some of the like a some a wonderful workflow of a feedback workflow. Based on feedback workflow and then so if feedback like a like a just plain text

if we say oh, I got to find some big damage in the like a front area or some bumper area and then based on that feedback and agent uh take the feedback and then try to analyze the feedback. Okay, based on that and running on like a based on AI model, uh like a find out the market value of this vehicle. For example, this car like a

Mercedes and then oh, this is like a $6,000. And then when we repair this a car, maybe cost into $70,000. It doesn't make sense to repair the car. We just dispose the car or we can donate this car somewhere to some Middle East for I don't know how to use that though. Or uh if you like a oh, we can just repair the car like a $1,000.

Okay, that's good. We're going to make the repair. And then we and then clean the car or some other feedback. Oh, there's no damage. That's good, but we got a very many dog hairy on the backseat. And then basically we don't allow the customer to bring the pet in the vehicle, but there are many cat or dog hairs. And then we definitely need to clean the car.

We going to maybe give us some extra charge to the customer. So, this really happening kind of thing and specifically a pricing the market pricing analyst kind of thing is very specific need to AI model and kind of agent AI, which isn't can be developed in this our develop team. Maybe other develop team maybe can develop it there, but the agent AI. So, this is a URL.

You can actually go to the URL and then fork and use that for free. >> [snorts] >> So, here's my ID. Everybody can do look it up. Okay. So, I'm going to run our first like a remote agent AI running Quercus. And then the other one is multi agent existing because you can see that two uh I may have a two Quercus Java project. One is a

multi agent existing and the other one is a remote AI I'm going to run remote first because it the multi agent existing try to connect to initialize the connection or agent A2A. So, I'm going to need to run So, when I run the application and the join the data and then go to here is the fake system. Of course, this UI also generally by AIs. Of course.

Anyway, so you can actually give us some feedback like open the like a some image. Of course. So, you can actually take the photos of the vehicle and then just some road rental and put in the text. Or if you find some very critical like a damage, you can actually type in the feedback. And the first investigator or first step of the rental car and then put

in the data. And then when it And then if you put in the some kind of comment, and then it trigger multi-agent system right away. And then when I go back to first multi-agent system under the record Java directory. Of course, when I go to application properly, I'm using today like a OpenAI model here. Here's OpenAI model and then GPT-4, but it's small model. So, still working.

So, whenever you build new agentic system, you don't need to always use the large language model. So, sometimes you can just use a small model because agentic AI could be like a very small microservices. So, maybe at the very start, you can have a one agentic AI keep adding more features, features, feature communicating multi-AI models. That's not good. So, you can create like a one or two

functionality one specific agent that could be small model. And then you have a new workflow or business capability, you need to create a new one. Just like a new And then that is a still connected maybe small reasoning model. 6 months later, you have like a hundred agentic AI application just like a hundred different microservices. So, that is a more recommended way to design And then when

I go to like a model is all like a database entity. Here's agentic here. Agentic You can see that I have like a 1 2 3 4 5 6 7 8 9 10 10 different agent today. As you can see like a checking car condition feedback or car image analysis. This model is special like image analysis AI model and like a cleaning agent and this position agent

and a disposal proposal agent and then feedback analysis agent and then supervisor agent and human like approval agent and maintenance agent pricing agent and I also have the workflow. The first workflow is a car processing So car processing workflow you can see that as developers stand simple. You just need to sequence agent annotation which is a wonderful design pattern sequence design pattern and with the that and

the sequence design pattern you can see that sub agent here. I have three sub agent. Car image analysis and a feedback analysis workflow and feedback supervisor agent and last is a car condition. This is a car condition feedback agent is the last state of the your car condition kind of thing. So this is a sequence of it going to try to image analysis. And then there is

a new image update uploaded we going to just pass and then go to feedback which is like typing the in the UI. Go to UI this is a feedback. And then based on feedback and you can call the other stuff and then the in the fleet supervisor is you can saw that in the slide that. So if I go to feedback analysis workflow which is the the

other Oh, it's a stuff. Sometimes it's all my IDE. Oh, weird. Yeah, something weird is stuff. All right. And And Oh, yeah. Is something changed there? Yeah. Let's see. Oh, yeah. Maybe maybe may may my laptop is a feel getting warmer here. Looks good. And then back to the UI and try to reload. Okay, looks good. Okay. And then uh the feedback here so feedback analysis workflow

and you can here this feedback workflow actually using parallel design pattern here. And the parallel design which is sub agent So feedback analysis agent sub agent using that. And then when I go to one of like a the feedback analysis agent and then you can see that all the course based on the agent annotation which already make a your just a general Java interface as agent AI

kind of thing. And then one of the thing is a supervisor here for this supervisor agent. And then we using as actually use your supervisor agent. Pretty obvious. Or like a uh Quarkus messaging point integration annotation. So whenever you start that combination of agent design pattern, you can easily use that this annotation kind of stuff. And then supervised agent, you can actually multi agent pricing, disposition, and

the human in the roof and the kind of thing. So if you want to try to add the human a probable agent, so of course using agent annotation. And then specifically So this human in the loop annotation just allow you just stop your some processing until someone actually give some action on your application. some like a some here like a when you like analyze your vehicle the

job market value and then if you more than like a $6,000 or something like that, I'm going to give you some like a human in the loop kind of thing. So if you go back to here, I'm going to try to this one of the vehicle like a X5 in the minutes right now. So if I say looks like the car is a hit a tree is

damaged beyond repair. And if I click on uh remote agent first and then a sync execute uh kind of thing and then it will Oops, we got to something. exception Tell us something change the car. Yeah, this is a like a we don't have any uh the image upload. That's why you can't find that error right now. And then it will be take some time uh to

call AI model. In the meantime, so let me try to open the other project remote A2A. And then go to remote A2A you can see that you can see that three like a Java class. One is a pricing agent. And pricing agent is a general AI services a pretty much how do you find out prices based on like a vehicle brand like a luxury brand or a

premium and like a truck kind of thing and also like a year of your vehicles. And then you can actually estimate the market value using like AI model and like a some base on US dollars. And then here is a how do we define agent car using Java method. You can actually put on the here public agent car annotation. And then put in the some kind of

agent like a some identity like a URL and then like a name and also like a agent capability. And the last thing is the agent skill So that's exactly how do you define and of course last thing is agent executor which is the like a how to process response and request kind of thing. So. I don't know what is wrong. Let me try to start again. So

network is good right now. Okay. It's go on. And talk. Running on database also. Okay, working. And then go to UI. Try put in the action letter. >> Oh yeah, car image is is we don't use a car image today. So Okay, now you can see that. So the remote AI agent is just invoked and then this is estimated like a 61 $1,600 for the market value.

And then based on that, we not going to we going to recommend dispose this kind of stuff because of Back to the agent, you can see the workflow pulse and awaiting for human approval decision. And go back to UI, now you can see the approval needed. And then when you go here and then here is the AI recommendation. Looks like here is the my damage report and

then the car sustained damage which is described beyond the repair due to kind of thing and then here is the estimated $61,600 is way expensive than original like a kind of thing. And then if I go to dispose and then back to the multi-agent system. And then their final decision still like waiting for like a your like your like a super boss on your company. So now

you can see that the pending disposition. Or you can actually directly go to disposition department, change the agent AI and then just a process disposition right away. So this is just some of the example how do you bring the like a parallel sequencer and like a supervisor and A2A order together up in the all together to build your agentic systems. Just imagine that you already have a

business workflow, your application which is a not AI application today. And then you think about the which part of the my application can be replaced with AI agentic system. You can do almost everything. But sometimes there's some of the application based on like a condition or some of the application needed to loop or like a parallel things. So you already build your business application with your like

your Java syntax. And now you can replace it with a multi-agent pattern with the application. So, when you just complete the application development for the AI system and agent AI system, and you probably start you're actually working with your team. How do we actually we develop multi-agent system not only my local, but also teams and testing environment production. And then if you're using like a like a

commercial AI platform just like my demo, like a OpenAI or some other stuff, you spend money, but just for the demo, it's just a penny dollar, but your daily job, I cannot be sure is maybe not a lot of money. So, a lot of people actually using like a local model like using a llama kind of thing is a small token, faster, and no latency just like

my first demo failure. The problem is that when you pick it up any AI model locally, and then maybe it doesn't support agentic stuff, or maybe not good answer just like that. But, give it a try local model first. And then when you actually deploy application, you probably better verify your agentic AI system capability and Most likely in production environment. Not production exactly, but similar production. That

is a like a more testing environment or staging environment. At the time you probably want to run your some enterprise private AI model for sovereignty or some kind of security. So, if you're using one of the open source for allowing you to run AI model and accelerating GPU processor, but also export your inference server URL. And then after that, you can maybe deploy many VLLM as a

container on Kubernetes, or you can directly use like a cloud platform for the production as on. And the product developer, sometimes you need to like a manage your security coding for your agent AI as well. MCP basically not provide any security capability. You do your own security stuff. You can also using like a API gateway, that is a part of my second talk tomorrow. But anyway, there

are some OWASP of security practices. And then three of them OWASP actually give you some how to secure your agent AI application with AI model. For example, like number one is a prompt injection. Just like a SQL injection, you're going to avoid using like a guardrail, input output guardrails. And like a API gateway give you some like a authorization and authentication. And also last thing is more

important is accessible agency. So you don't want to give you some fully authorization or credential or permission to do your local agents, like a open core example. So give you some like a quota or resource limit or like a number of token usage. And then not give you some 100% agent. That's I showed that judge API and human in the loop part of your agentic system. Maybe

so at some point in the future an AI trained AI and agent AI create a new agent AI, something like that. And then you probably need to don't need the human in the loop eventually. And but still we can't trust 100%. So that's why you don't need to put every single permission to the agent AI today. And the last but not least, observability for Java developers always.

So, you're going to trace all telemetry data with a like a visualizing like a dashboard, like a like a Yeager and open telemetry and using like a micrometer. So, you can find out So, when you access like a AI model tools and then you're going to find out where is the actual problem and then which part which is section is it takes a longer than any others.

And then here's a like a future of your agentic system. You probably heard about IoT, it's the internet of things. Things means your any electronic appliances. As As long as your electronic appliances connect to internet network and they connect to the uh each other. So, you can actually control every single like a your freezer, TV, audio, your door lock, or lights on your mobile. Something like a

like a smart thing in Samsung. So, you can actually destroy all agents just like your appliances as long as they're all connected by internet. That is a IOA. And then Java still really good language to build your IOA architecture or multi-agent system. Of course, you can keep doing standard open source protocol 808 and MCP with a more like a ecosystem expansion. And the last thing is the

just a couple takeaways from this session today. so, first of all, keep looking at the MCP, but MCP is a not always a good answer. So, you only to use MCP specifically like a discoverability rather than just a pure AI model like a search. And also when you design multi-agency AI system, 808 is a necessary gives some great benefit of language agnostic and then a multi-developer team

schedule and life cycle as well. And what we call is always a better for your agentic recommendation rather than directly decision for your mission-critical last thing is always observability one of the great part of the application for when application deploy production. So that's it. Thanks for attending today. I'm happy to take the questions. >> [music]