3. Asynchronous Programming for AI Agents | Complete Agentic AI Course

Added: 2026-05-10

[00:00:01]Hi guys.

[00:00:02]My name is Bapi Ahmed and you are welcome to my YouTube channel.

[00:00:06]So guys, this is the third lecture of our complete agentic AI course.

[00:00:11]Uh in our previous video, I have already discussed the complete evolution uh of agentic AI, like how agentic AI came.

[00:00:21]Then I have already given you the detailed introduction to agentic AI, like how agentic system works, what are the key components and characteristics are available.

[00:00:31]Now, slowly we're moving to the uh AI agents core concept. That means the practical development concept. Uh but before that, we have to also understand all kinds of orchestration frameworks are available.

[00:00:48]I think I already told you uh in my previous video. Uh like there are uh some components are available, especially whenever I'm talking about uh the agentic AI.

[00:00:59]Uh one of the component is the orchestrator, right? Orchestrator means there we use some kinds of framework, okay? With the help of these are the framework, we create, we implement the AI agents, whether it's a single agents, whether it's a multi multi AI uh agent system.

[00:01:16]Uh we try to create these kinds of things, right?

[00:01:20]So, there is a concept, guys, uh you have to understand before I start with these kinds of orchestrator framework.

[00:01:28]The concept name is asynchronous programming, okay?

[00:01:31]So, why this asynchronous programming is required? Uh because if you see, uh going forward, we'll be creating the multi-agent system.

[00:01:40]And to create the multi-agent system, guys, we'll be using these kinds of orchestrator framework.

[00:01:46]And internally, this orchestrator framework uses asynchronous programming, okay? That means it will run your agents in parallel. Let's say you have created uh 20 agents. So, what it will do instead of running, uh, agents as a sequentially, it will run all of the agents in parallel, so that your execution would be more fast.

[00:02:08]So, this concept I'm going to discuss in detail, guys. No need to worry. Uh, first of all, let me show you one thing actually, uh, I have just figured out.

[00:02:17]Let's say if I go to the Google. So, here if I search like is LangGraph uses asynchronous in the back end for multi-agent agents. So, I think you know LangGraph is one of the orchestrator framework. With the help of LangGraph, we create agentic AI applications, right? And we'll be also mastering this LangGraph inside our codes.

[00:02:37]So, as you can see, the response was yes, LangGraph is, uh, designed with first-class asynchronous supports in the back end for multi-agent system. That means, uh, it is utilizing the asynchronous programming, asynchronous concept in the back end, okay?

[00:02:53]Now, if I just to go below, let's say I have asked for about the AutoGen, because AutoGen also will be covering inside our codes. So, as you can see, AutoGen also utilizes asynchronous programming at its core, but it is, uh, architecture fundamentally different from the LangGraph state, uh, LangGraph state machine approach. But internally, it is uses asynchronous programming concept. Now, again I asked like, uh, what about CrewAI, okay? So, you can see CrewAI also supports asynchronous execution, but it, uh, approaches orchestration differently than LangGraph and AutoGen. While, uh, LangGraph uses, uh, a state machine and AutoGen uses, uh, actor model, CrewAI is built around role-based collaboration and process-driven execution model, okay?

[00:03:42]But, the main funda is that all of the orchestrator framework we are using for developing these kinds of multi-agent application, internally, it is uses asynchronous, okay? Asynchronous programming.

[00:03:55]Now, before I start with these are the orchestrator framework, first of all, I want to clarify what is asynchronous programming, why it is required, how asynchronous works, okay? What is parallelism, what is uh let's say sequential execution, each and everything I'm going to clarify. Then we'll start with the uh orchestrator framework understanding.

[00:04:15]But after that, there is one more topic uh we have to cover, which is nothing but Pydantic Pydantic validation. This is also important because you'll see that whatever large language model we're having, it will generate the unstructured output. And to make it structured, even whenever we're giving any kinds of prompt, to make our prompt uh more structured, we use this Pydantic validation, okay? So, this Pydantic validation we'll be understanding in the next video, but in this video, I'll only focus on the asynchronous understanding, okay? So, here I'm going to give you the detailed understanding of asynchronous with the theoretical understanding as well as the practical understanding as well.

[00:04:55]So, let me show you guys what is this asynchronous. After that, your understanding would be more clear and you can easily understand these are the framework whenever you'll be doing the coding.

[00:05:07]So, let me give you the definition of the asynchronous programming. So, here is the definition.

[00:05:12]Um here's the simple definition you can see. Asynchronous programming in Python, okay? You can see asynchronous programming in Python is a programming paradigm that allows code to handle, okay, multiple task uh concurrently without blocking the program's execution.

[00:05:31]It is primarily used to IO-bound task, example network uh request, file input and output operation, database queries, okay? Allowing the program to perform other operations while waiting for slow external events to complete. That means this I think asynchronous programming will help you. Okay, asynchronous programming will help you. Okay, asynchronous programming will help you to run your task in parallel. Okay, so you are not supposed to wait for the uh execution. Let's say we know that we use synchronous synchronous programming so far. Yes or no, guys? We use synchronous programming so far. In synchronous programming, what happens?

[00:06:12]Let's say if I execute a code block first of all, it will complete that, okay? After the execution is complete, okay, then it will execute the second part of that particular code, okay? But in between, let's say if you are waiting for the execution, okay, if you're using asynchronous programming, it can run run another task in parallel, okay? So, these are the let's say functionality we'll be getting here.

[00:06:36]Now, you can ask me why this is required. Okay, why this asynchronous programming is required inside AI agents implementation? Agentic AI, you can create two kinds of agent. One is the simple agent.

[00:06:48]Okay, one is the simple agent. So, basically, simple agents you create only one block. Okay, it can only handle one particular task. Okay. But whenever, let's say you have complex problem, you have to divide the task in a smaller chunks. And what you will do, you will be creating multiple agents, okay?

[00:07:10]Multiple agents you will be getting.

[00:07:11]Let's say this is agent one, this is agent two, this is agent three, okay?

[00:07:16]And what will happen, you will assign the task for all the agents.

[00:07:21]And these agents will be executing either independently indepen or dependently.

[00:07:35]Okay, dependently.

[00:07:37]So, it's your design philosophy. If you are making it as an independently, that time it will run as an independently. If you are making it to dependent, okay, it will run as a dependently.

[00:07:47]So, basically what happens, let's say if you run these are the agents, okay? These are the agents in a synchronous programming, okay? In a synchronous programming, what will happen? First of all, these agents need to be completed. These agents execution need to be completed. Once these agent Once these agents will be executed, then it will move to the next agents, okay?

[00:08:08]Next code block. Then these agents will be executed, okay? Once it is completed, then it will go to this particular agents, okay? Then it will try to run this particular agent. So, let's say this agents is taking 3 minute to run.

[00:08:21]Sorry. Let's say here I can just tell you.

[00:08:25]Let's say this agents is taking 1 minute to run. These agents is also taking, let's say, 1.5 minute to run, okay?

[00:08:31]These agents is also taking, let's say, 1 minute to run. So, what is happening?

[00:08:35]You have to wait for 1 minute. Again, you have to wait for 1.5 minute. Again, you have to wait for 1 minute, okay? So, if you like uh add all of the time, you will see that at the end you are having, okay, 3. 5 minutes. 3.5 minutes you have to wait for the execution. But, if you run this task in parallel, okay? If you run this task in parallel, let's say this particular agents will do the online search operation. So, basically if you're doing the online search operation, you will be hitting some URL, right? Drive URL. And to get the response, this will take some time.

[00:09:06]Let's say sometimes this web server might be slow. That time it will be giving you slow response. So, instead of waiting for that, you can execute your other agents. So, let's say this agents will try to collect the uh images. These agents will try to collect the, let's say, any other file, okay, from the internet.

[00:09:23]So, don't wait to execute any other agents. Just try to run them in a synchronous way, okay? In a parallel way. So, each of the agents will be running in a parallel way. So, let's say the if this agent is also taking uh 1 minute, okay? So, simultaneously we're running something, okay, in the back end. So, you are not supposed to wait for 3.5 minutes. Get it? So, that is the things I just wanted to tell you. So, let's say whenever you are creating multi-agent system and whenever you are creating, let's say, independent connection, okay, independent, let's say, policy, that time you should use this asynchronous programming inside um inside, let's say, Python or let's say, whatever programming you're using, you have to follow that. And if you see any kinds of agent's code, you will be uh seeing people are using this asyncs, okay?

[00:10:10]Uh asyncs.

[00:10:12]This particular syntax, people are using that.

[00:10:14]Okay. So, what is this async? Async means asynchronous, okay? Asynchronous functionality. So, in Python there is a library called asyncio. So, we'll be following that particular library to implement this particular code, okay?

[00:10:25]So, let me give you one example of asynchronous and synchronous programming.

[00:10:30]So, let's say here I can write synchronous synchro- nous programming.

[00:10:44]And this side we have asynchronous programming.

[00:10:59]So, in synchronous programming, what happens?

[00:11:01]Let's say what I can do, I can give you one example.

[00:11:07]Uh let's say here mm Let's say you are you are having a mm you're having a mm gas stove, okay? Gas stove.

[00:11:23]Uh in this gas stove you only have one um one fire section, okay? One fire section. So, let's say you are having uh three dishes.

[00:11:35]Okay, you are having three dishes to cook.

[00:11:42]So, what you will do? First of all, you will take the first dish and you will cook that. Once first dish is complete, then you will take the second dish.

[00:11:50]Then you have to complete, then you will be taking the third dish, then you will be completing. Okay, that's how you can see it is taking T1, it is taking T2, it is taking T3 time. Okay. So, basically you have to wait for you have to wait for the previous execution or let's say previous task to be completed, then you can start the remaining task. But in asynchronous programming, what happens? Let's say you are having same gas stove, but here you are having let's say three fire section.

[00:12:20]You're having three fire section and you are having three dishes.

[00:12:23]Okay, let's say dish one, dish two, and dish three.

[00:12:29]So, what you have to do? You just need to run all of them simultaneously.

[00:12:36]Basically, you are giving three dish to the three fire section. Okay? Now, at the T1 time, okay, your all of the dishes will be completed. So, you are not supposed to wait for the T1, T2, and T3 to be completed. Okay, so this is the difference between synchronous programming and asynchronous programming. I hope you get it, guys.

[00:12:55]So, in Python, we usually follow the synchronous programming. That means if you're running a function, first of all, that function would be completed, then the remaining code would be executed.

[00:13:04]Now, in programming, we we call it as a subroutine. Let me just write here.

[00:13:11]Sub routine.

[00:13:16]And we also call it as coroutine.

[00:13:21]I'll be discussing about what is this.

[00:13:24]Okay, coroutine.

[00:13:25]So, what is subroutine? So, let me a program to explain. Let's say here I can write a function.

[00:13:32]So, I'll just write a function. Let's say def Okay? Def So, let's say I will Um I will give the function name fetch.

[00:13:48]Okay?

[00:13:49]Fetch, let's say data.

[00:13:51]This is the function name.

[00:13:53]So it is having some code inside that.

[00:13:58]Okay? Now, here I'm creating another function. Let's say def main.

[00:14:04]Okay? Now, what I'm doing? I'm calling this particular function. Okay? This function inside this particular main function fetch data.

[00:14:15]Okay? I'm calling inside that.

[00:14:21]I'm calling inside that.

[00:14:23]Sorry.

[00:14:24]Yeah.

[00:14:25]Now after calling, let's say in this main function also there are some code line.

[00:14:31]So, what is happening here? Let's say if you're uh if you're using sub routine, so that time uh whenever you are executing your code, first of all, your code will uh come here. Okay? Your code will come here and it will see you are calling a function inside that. Which function?

[00:14:49]You are calling this particular function. Okay? Now, what it will what will happen? First of all, it will go to this function and it will execute all of the code.

[00:14:57]It will execute all of the code. Now, let's say you are running fetch data, that means let's say you are trying to fetch some kinds of data from the internet. You are using some kinds of API, some kinds of URL, okay? And whenever it is hitting that particular API or URL, it is taking some kinds of time, right? So, you have to wait for this particular time.

[00:15:17]So see, once this time is over, that means this execution is over. Then you will be able to execute your remaining code. Okay?

[00:15:26]Till then you have to wait for this execution. Okay?

[00:15:30]So, this is the idea of subroutine. That means you are waiting for a task to be completed, then your remaining code would be executed. Then your remaining code would be executed. Although you are waiting here, although you are waiting here, you don't have any kinds of other task. You just need to wait for the execution. Okay? And once execution is completed, then you will be able to execute, you'll be able to see the other execution of the program.

[00:15:57]But in coroutine, what happens? So, let's say here I'm having a function.

[00:16:01]Here I'm having a function. And uh we use something called asynchronous. Okay?

[00:16:06]Asynchronous syntax. So, for this we use something called async.

[00:16:10]Uh async, okay? This is the keyword async. So, we'll write the function as def. Let's say fetch data.

[00:16:19]This is the function. Let's say inside that you are having some kinds of code.

[00:16:24]Okay? Now again you are having a main function here. So, I'll just write def main.

[00:16:31]So, what you are doing? You are calling this particular Um okay, you are calling this particular function def.

[00:16:39]Sorry, uh fetch.

[00:16:43]Okay? Fetch data.

[00:16:46]You're calling that.

[00:16:48]And inside main you are having some other code.

[00:16:51]Okay? You are having some other code as well.

[00:16:54]Now what is happening? Just try to see.

[00:16:55]Whenever your Python will come here, it will see that you are executing a function. Which function? This function you are executing. And it will see this particular keyword called async, okay?

[00:17:06]Then that time Python will automatically understand that this code you have written, it will run in asynchronous way. That means let's say here you are doing a API call, and it is taking some time T1. Okay, instead of waiting for this particular time, again it will come here, okay, and execute the remaining code you have, okay, after this function. That means at the T time itself, this code would be executed and this code would be also executed. So, you are not supposed to wait for the previous execution. So, this is called coroutine. And if you're using this async, these are the things, so it internally uses this concept. And now we'll go for the practical, we'll try to see like practically everything, how it works.

[00:17:48]Uh then I think your understanding would be more clear, okay.

[00:17:51]First of all, I'm going to explain the synchronous programming.

[00:17:56]Okay.

[00:17:58]Now, here I'm going to write two function, let's say for the first function I'm going to write uh fetch DC fetch weather.

[00:18:17]Okay, fetch weather.

[00:18:20]Um and the second function I'm going to create def fetch news.

[00:18:30]Fetch news, okay.

[00:18:32]Mhm.

[00:18:33]Now, what I'm going to do, I'm going to import the time module as well just to see the execution time.

[00:18:42]So, import time.

[00:18:47]Import time, okay.

[00:18:49]Now, inside that, as of now, I'm not going to write any logic, simply I'm going to write just a print statement.

[00:18:53]I'm going to give let's say fetching weather data.

[00:18:57]Then here I'm going to just mention a time.

[00:19:01]Uh let's say to fetch the weather data, you have to wait for some time, okay.

[00:19:06]So, this time I'm going to assign with the help of this time module. So, here I'm going to give let's say I will be waiting for 4 seconds, okay?

[00:19:15]4 seconds. So, it it is for the simulate uh network delay. Let's say if you are hitting any kinds of API, so definitely to get the response you have to wait for some time. So, let's say this time I have set 4 seconds here, okay?

[00:19:28]Now, once uh we stop for 4 4 seconds, now simply I'm going to just print let's say weather data fetched, okay?

[00:19:36]So, this message I'm going to write.

[00:19:38]Now, similarly here also I'm going to write uh I'm going to write facing facing news data.

[00:19:46]And again I'll give some time. Let's say here I've given 2 seconds.

[00:19:51]And uh once my data news facing is done, so I'll tell news data faced, okay? So, as of now, just try to consider this is a function. This will fetch the weather information.

[00:20:02]And this will fetch the news, okay?

[00:20:06]Now, if you see this function and this function doesn't have any uh dependency. These two functions are independent. Okay, these two functions are independent. That means if you want to fetch the weather, you don't need the news.

[00:20:20]If you want to fetch the news, you don't need the weather. So, these are independent function. Okay?

[00:20:26]But once I will execute this code, okay, let's say if if I write another function here, I'll just write another function def main, okay? In the main function, I'm going to call uh I'm going to call these two functions. See? First of all, I'm starting the time just to see the time like how much time it takes to execute the two function. So, that's why I'm starting the uh start I'm taking the start time. Then I'm calling these two functions together, fetch weather and fetch news. You can see fetch weather and fetch news I'm calling.

[00:20:56]Then I'm taking the end time, then I'm doing the subtract operation from end time to start time. And this will be uh this will be my execution time of my program.

[00:21:07]But if you see here these two functions are independent. This this two functions is not dependent.

[00:21:14]Although it's independent, okay, it's not dependent.

[00:21:17]So whenever you will call the function you have to wait for the you have to wait for the previous function to be completed to run the next function.

[00:21:29]This is the issue, okay? So I can see these two functions are completely independent. But whenever I'm calling this function, first of all this function will execute. So let's say whenever you will execute the program, so your interpreter will come here, okay? Your interpreter will come here, then it will go to inside this particular function. Then it will execute all of the code and here it will wait for the 4 seconds, okay? 4 seconds it will try to wait.

[00:21:55]But see, in the first 4 seconds it doesn't have any work to do, so it will be waiting.

[00:22:01]Then once 4 seconds is over, this code would be executed, then your program will come here. Okay, then it will be executed. That means first of all the previous function would be executed, then the next function would be executed. So you can also check. So let's say if I want to show you, so I'll call this particular main function here.

[00:22:19]Okay, I'll call this main function. Now if I execute, see, facing weather it is waiting for 4 seconds. Now weather fits. Now see, facing news, now it wait for 2 seconds, then news fits. And total time taken you can see 6 point something seconds. Okay, now you can also take this code in one of the amazing website called Python Tutor.

[00:22:43]Python Tutor.com, here also you can visualize this code.

[00:22:49]Let me open the Python Tutor.

[00:22:53]Now I'll select the Python programming.

[00:22:58]I'll paste my code here.

[00:23:01]Visualize the execution.

[00:23:10]Okay.

[00:23:11]Now, it has started. Okay, it has started. Now, simply time is not defined. So, okay, so the basically I need to import the time here, right?

[00:23:21]So, let's edit the code.

[00:23:26]So, here I'll import the time module.

[00:23:31]Put time.

[00:23:33]Now, I'll visualize the execution.

[00:23:38]Import time. It's giving me an error.

[00:23:40]Time file not found or supported. Only these modules can be imported. Okay, because this is a like a website, okay, Python Tutor website. So, here you can you can't import any Uh let's say these are the library you can't you can import, but some other library you can't import. So, for this what I can do, I can remove the time as of now.

[00:24:01]I just wanted to only just let you know that how it is executing. Let's say I will also remove the time part.

[00:24:07]Uh here also I'll remove the time part.

[00:24:10]Here also.

[00:24:11]And here also.

[00:24:13]Uh let's say this is my message.

[00:24:16]Okay, this is my simple message.

[00:24:19]Let's say execu- -ted.

[00:24:26]Now, simply do the visualization.

[00:24:31]Okay. Now, see.

[00:24:33]Um here I have the control. So, first of all, Python interpreter will come here.

[00:24:38]Uh it has seen like here I am having a function called fetch weather. Then, it will go to the next line, that is next function.

[00:24:46]Then, it will go to the next function, which is main.

[00:24:50]And in the main function, you can see uh I'm calling here this particular main function. So, it will go enter into the main function.

[00:24:57]And it will see like I'm calling fetch weather function, okay? So, it will go inside fetch weather and it will do all of the operation.

[00:25:05]Okay, see, it is doing all of the operation. Now, let's say this function is taking some time, so it will wait.

[00:25:10]Okay, it will wait for 2 minutes, 1 minute, okay? How much time it is taking, it will try to wait for that.

[00:25:16]So, once execution is completed, then again, it will come here. Okay, then you can see it will execute another function, which is fetch news. Now, again, it will go inside fetch news then it will do all of the execution and try to come here. That means you have to wait, okay? You have to wait for the previous execution to be complete, then you will be able to run the new code.

[00:25:36]Okay, that's how you have to wait, okay?

[00:25:38]You have to wait uh for the previous execution. And definitely, it is taking lots of time. And now, just try to consider if you're running a multiple agents together and if it is running synchronously, so first of all, first agent would be completed, second agent would be completed. So, execution time it will take more. That time we run it is an asynchronous way. So, that we are not need to open We don't need to open for We don't need to wait for the previous execution, okay? The time it is taking it's completely fine. I will simultaneously run for all of the function and it will be executing together, okay? So, now we'll try to see that particular example as well, how it will work. Now, we'll see the synchronous programming.

[00:26:21]Sorry, asynchronous programming.

[00:26:26]Asynchronous programming.

[00:26:28]Now, here to uh implement asynchronous function, you need to import one library called import Sorry, import.

[00:26:41]Okay? asyncio, okay? asyncio, this particular library and I'm going to also import time library.

[00:26:50]Let's me import all of them. Then here I'm going to again write the same function.

[00:26:56]Same function, I will copy the code.

[00:27:01]And simply I'm going to mention here.

[00:27:02]Now, instead of giving simply this definition, I'm going to write async keyword, okay, before that. Now, once I have written async keyword, okay, async keyword at the first of this particular function, now Python will automatically understand I need to run this function in asynchronous mode. And here it is taking the time, so maybe I can use another keyword here called await. Okay, await.

[00:27:27]So, simply I'm going to give it here.

[00:27:31]Okay?

[00:27:32]Even you can also return something if you want, okay? You can also return like uh what is the return this function will be returning for you.

[00:27:40]Mhm.

[00:27:41]Now, same similar wise, I'll also do it for this particular function.

[00:27:46]So, async.

[00:27:51]Okay? Now, simply here I'm going to write await.

[00:27:54]Okay? Await.

[00:27:56]So, why you are writing await here?

[00:27:58]Because here it is taking the time, okay?

[00:28:01]Here it is taking the time.

[00:28:04]And whenever here it is taking the time, your Python interpreter will come here.

[00:28:09]And whenever it will see the await, so it will tell like you don't need to wait for this particular execution, so you can execute your other code, okay, whatever you have. So, this code would be executing. And at the same time, you can also execute your other code, okay? I'll tell you, okay, how it will execute.

[00:28:27]Uh then simply in the main function also, I'm going to make it as async.

[00:28:35]Okay, async. And here uh instead of calling like that, I'm going to simply call it as await.

[00:28:44]Uh asyncio.gather, okay? There is a function.

[00:28:48]And inside that you have to give the fetch weather fetch weather uh function and fetch news function. Both you have to provide, okay? Then you can uh calculate the end time.

[00:29:01]And simply you can bring the time taken of this particular function.

[00:29:06]Now, if you want to execute, uh what you can do, you can simply uh you can simply call this main function. How? You can use the await keyword main. Now, see, if I execute see what will happen.

[00:29:25]Okay, um there is a error.

[00:29:28]Oh, sorry. Uh whenever you are using this await, right? You don't need to use the time that time.

[00:29:33]Uh you can use as since uh as since I will not sleep, okay? So, you are not supposed to use time that time. Okay, you have to use as since I will not sleep. Okay?

[00:29:45]Now, same things I will be giving it here.

[00:29:52]Same things I will give it it to here.

[00:29:55]Uh now I think it is fine. Now, let's execute.

[00:30:01]Now, see, guys.

[00:30:02]It has taken only 3 seconds. And if I show you my previous code, it has taken 6 seconds.

[00:30:08]Okay? So, the time reduced by half.

[00:30:12]Okay? The time reduced by half. Just try to consider.

[00:30:15]Now, just think like this is a big program. Okay, this is a big program.

[00:30:19]This is a big agents and it is running so many stuff. Now, if you run it run it in a asynchronous programming, now just try to consider how much time it should it should take, okay? But if you are using asynchronous programming, see, it will be reducing the time half.

[00:30:36]Okay? Because it is running everything in parallel.

[00:30:39]It is running everything in parallel.

[00:30:42]Okay? So, you are not supposed to wait for the previous execution to be complete. Okay, so all of the executions are doing simultaneously.

[00:30:52]Okay, so that's why this asynchronous programming, okay, this async IO is required whenever you are implementing uh any kinds of AI agents uh with any kinds of framework, whether you are using autogen, you are using LangGraph, you're using CrewAI, try to use this particular things in your development.

[00:31:11]Okay?

[00:31:12]This is good practice.

[00:31:14]There are two concepts you'll be getting, which is uh the first is para llelism.

[00:31:22]Okay?

[00:31:24]And the second thing you'll be getting con cu rrency.

[00:31:31]So what is parallelism? Running multiple uh tasks simultaneously using multiple threads.

[00:32:01]Okay, or process.

[00:32:08]And what is uh concurrency? So let me write it here.

[00:32:12]Um simply here I can write concurrency.

[00:32:23]Concurrency means uh managing multiple tasks that can start run and okay, finish with overlapping times.

[00:32:57]Okay.

[00:32:58]So, let me show you a graph. I think by seeing the graph, you will be able to understand what is the exact meaning.

[00:33:14]So, this is the graph.

[00:33:16]So, this is the concurrency. You can see uh task is running, okay? Context switching to the task two, then again task one is running. Again, it is doing the context switching, okay?

[00:33:29]But in parallelism, you can see it is utilizing, okay? It is utilizing multi uh multi-core, okay? Let's say uh in the first CPU core, it is running task one and in the second CPU core, it is running task two.

[00:33:45]But here, it is only utilizing the same core only, but doing um doing this uh concurrency operation, okay?

[00:33:53]So, guys, I think you have seen this asynchronous concept. Uh the main thing is that right now, all of the orchestrator framework uses these kinds of asynchronous uh functionality in their back end. So, we don't need to manually uh use the asynchronous inside our development, inside our code. But if you want, you can also use. Uh if you want, you can also uh design your own pipeline, design your own agents. That time, you can write the code from scratch. But whatever um let's say uh orchestrator framework will be using like LangGraph, then AutoGen, CrewAI, right? So, everything uh already having these kinds of things are integrated okay in the back end. So, I don't need to take care of this part. But, in future whenever I will do some coding, maybe these are the terminology will come. That time I want you to don't actually confuse with the syntax. Okay? That's why I have clarified each and everything before I go ahead with the AI agents implementation. So, yes guys, I think you have liked this video. If you have liked this video, please try to subscribe to my channel and hit the like button. So, yes, this is all about.

[00:35:03]Thanks for watching, guys. I will see you in the next video.