Agentic AI Using Python | How To Build AI Agents Using Python | Agentic AI Tutorial | Simplilearn

[music] Just think about how fast technology is changing right now. A few years ago, most people were excited that AI could answer questions, write content, or help with coding. But today, the conversation is shifting. People now want systems that do more than just respond. They want systems that can help understand a goal, break it into steps, use tools, make decisions, and help complete real work. That is exactly why this topic has become so interesting and so important. We are moving from AI that can simply talk to AI that can take action. And when you combine that idea with Python, everything becomes more exciting because Python gives us a simple and powerful way to build these systems in practice. So in this session on agentic AI using Python, we are going to understand what this concept really means and how it's different from traditional AI and why it matters in the real world and how you can also start building these systems step by step. We will also keep everything beginner friendly, practical and easy to follow. So even if this is your first time exploring this topic, you will still be able to understand the flow clearly. By the end of this session, you won't just know the meaning of agentic AI, but you will also learn how Python helps bring it to life through real projects and useful applications. So with that, let's begin this journey into one of the most exciting areas in tech right now. Let's start with what is agentic AI. We will begin by understanding the basic meaning of agentic AI in very simple terms. Then we have agentic AI versus traditional AI. We will compare both so you can clearly see how actionbased systems differ from response based systems. Why it matters in the real world. We will look at why this topic becomes useful across real tasks, workflows and daily work. Setting up Python for Asian projects. Here we will understand the tools, libraries and the environment needed to get started. We will also cover some important core concepts like planning action and learning where we'll explore how these systems observe, decide, act and improve step by step. Then we will finally move on to the demo part where we will build our first Python agent. Here we will go through the idea of creating a simple working agent from scratch. Along with this we will also make your agent smarter with memory and tools. Here we will see how to improve it so you can remember choose tools and it can perform better. Real world demo and deployment idea. Here we will connect everything in a practical use case and show how such a system can work in action. Safety risks and future trends. We will discuss what can go wrong, how to build responsibly and where the space is heading. We will also discuss some best practices and next steps. Here we will wrap up with useful tips, learning direction and ideas for what you can build next. Before we move on, let me share something really exciting with you. The applied agentic AI systems design and impact is designed for professionals who want to build real expertise in the next wave of AI by learning how intelligent systems plan, reason, retrieve information, use tools, and collaborate across multiple agents. So in this program, you will develop hands-on skills in multi- aent systems. RAG, MCP, planning systems, workflow automation, prompt engineering, copilot design, agentic UX, ethics, transparency, and go-to market strategy for AI products. So, what makes it truly powerful is the practical learning experience with 40 plus demos, 10 plus guided practices, seven course and projects, and one capstone project that helps you apply concepts in real businesses and product scenarios. You'll also get exposure to leading tools and frameworks like Langchain, Langraph, Autogen, Crew AI, NA10, Langsmith, Jupiter, MongoDB, Figma, Miro, Slack, and Azure based AI workflows. The program takes learners through the full agentic AI journey from foundations and prompt engineering to LLM internals, planning frameworks, multi- aent ecosystems, tool protocols, evaluation metrics, trust focused UX and product readiness with project-based learning like building rack pipelines, agentic rag routters, AI powered automation systems, trust first agent experiences, multi-agent workflow planners and production grade GTM systems. This program helps you move beyond theory and build a confidence to create, evaluate, and lead next generation AI products. So, now that you have a clear idea of what we're going to cover in this session, let's quickly test your understanding with one simple quiz question. So, which one of these best describes Asian AI? Is it A, a system that only gives text answers? Is it B, a system that follows fixed rules only? C, a system that understands a goal and takes steps to complete it, or is it D, a system that only works for robots? Let us know your answers in the comments below. So let us begin with the big picture because once this part is clear everything else becomes much easier to understand. Right now one of the biggest changes in tech is that software is moving from simply answering questions to actually helping people complete work. So when I say agentic AI think of it in the simplest way possible. It is a system that does not just give you a reply but tries to move a task forward. So instead of only saying here is the answer. It can understand the goal, check the situation, decide on a step and act on it. So a very easy everyday example is this. A normal assistant might tell you that the cheapest flight is here. An agent style system would compare flights, check your budget, match your preferred timings, warn you if baggage rules are bad, and then help you find the booking details. That is the difference. It behaves like a search box and more like a helper trying to finish something with you. In Python, this becomes exciting because Python makes it easy to connect logic, tools, browser actions, files, and decision making all in one place. That is why so many people are using Python to build smart assistants, browser helpers, research tools, and workflow bots. So that the main idea you want is remembering this. Agentic AI is about goal-based action. It's a software that can observe, decide, and do something useful step by step instead of only giving text. So now that the basic meaning is clear, let's move on to the comparison that helps most people understand it instant. So now that we're clear about what agentic AI means, let's compare it to the older style of AI so that the difference feels practical and not theoretical. So traditional AI is usually narrow. It is designed to do one task well. It may classify images, recommend videos, predict demand or answer a question. It gives an output and that output is used. But in most cases, the work still depends on a human or another system to decide what to do next. But in agentic, it's different because it connects several steps together. It looks at the goal, checks the current situation, and then decides the next move. It also uses a tool if needed, checks the result, and then it continues. So the key difference is not that it's magically smarter. The key difference is that it's more actionoriented. So you can explain it with a simple analogy. Traditional AI is like a calculator. You ask it and it answers. But agentic AI is like a junior teammate. You give it a direction and it starts working through the task one step at a time. Another simple analogy is this. Traditional AI is like a map showing you a route. But agentic AI is like a driver who notices the traffic, changes the route and refules if needed. He also tries to get you to the destination on time. So now that we've understood the difference, let us walk through why this topic is becoming so important in the real world. So the reason is simple. People don't just want softwares that talk nicely. They want softwares that can save time. So if a system can reduce repeated work, handle routine follow-ups, gather information, and keep tasks moving, that becomes immediately valuable. So think about customer support. A normal system may answer one question, but an agent style system can read the issue, check order details, pull policy information, and draft the reply, escalate only when it's needed, and keep the case updated. So think about content creation. A creator can use a smart system to collect research, organize points and draft a script online and even prepare thumbnail ideas along with which he can also create posting checklists. So this is why a topic feels so popular. It connects directly to whatever people are trying to do every day. They also save time, scale output and reduce routine effort. Another reason it matters is accessibility. Earlier automation often needed rigid tools and a lot of them also needed engineering effort. Now people can build helpful task systems faster, especially with Python because Python files let you connect files, websites, APIs, spreadsheets, and custom logic without too much of friction. So the big takeaway here is that agentic AI matters because it turns software from passive answer machines to an active work helper. And this is a very big shift. So now that we see that it's a real world value, we shall move on to the foundation that makes every agent work. So now that we know why this matters, let's break down the system into three simple pieces. This is where the topic becomes much easier to teach. First, we have the agent. The agent is the doer. It's the part of the system that receives the goal, tries to make progress, and in simple words, it's the decision maker. Second, the environment. The environment is everything around the agent that it can observe or affect. So, this could be a website, a file or an inbox, including a spreadsheet or a custom ticket or even a game screen. Third, we have interaction. This is the back and forth between the agent and the environment. The agent sees something, takes a step, gets the result, and then decides what to do next. So, I can explain this with a food delivery example. The agent is the assistant trying to place the order, and the environment is the food app, menu, delivery address, and the payment page. The interaction is the full process, checking options, selecting items, applying filters, placing the order, and confirming the result. So, there is always a doer, a world it works in, and a loop connecting the two. Now that the building blocks are clear, let's move on to the heartbeat of the whole system. How agents plan, act, and learn. So now that we know the three main pieces, let's understand how the full process unfolds over time. An agent usually works in a loop. First, it checks the situation. Then it decides what to do, then it takes that step, then it looks at the result. After that, it either continues, changes direction, or even stops. That is the basic flow. Observe, think, act and review. So let's make this practical. Suppose the task is find a laptop under my budget with a good battery life. The system may search options and then it compares the prices then remove weak choices and then summarize the best ones and then ask for follow-up questions if something is unclear. That is planning and acting. Now where does the learning come in? Learning does not always mean heavy theory. In many practical systems, learning simply means improving from feedback. So if the user says I don't care about gaming, I only want battery and weight. the system adjusts the next decision. So if it fails on one website, it can try another path. If that result was poor, it can redefine the next attempt. So now that the working loop is clear, let's move on to the common design patterns most people use while building these systems in Python. So now that we've understood the basic loop, let's look at some common ways people structure agents in Python. So this is useful because a good structure often matters more than a fancy idea. One common pattern is the planner and worker style. One part decides the steps and the other part carries them out. This is useful when the task is big and needs to be broken down clearly. Another pattern is tool based action. Here the system itself does not do everything directly. Instead it chooses from a set of tools. One tool might search for the web, one may read a file or one may summarize text and another may send an update. A third pattern is memory plus action. In this setup, the system keeps useful notes from earlier steps that helps in avoiding repeated mistakes and makes follow-up decisions. So, these patterns are popular because they keep Python Asian projects clean, flexible, and easier to debug. Now that we've seen how these systems are designed, it is the right time to discuss the serious side of this topic, and that's risks and responsible use. So, now that we've covered how to build agents, we will now be honest about what could go wrong. So this part is important because the more action a system can take the more careful we need to be. The first risk is wrong action. If the system misunderstands a task, it may still do something confidently and then create real problems. A bad summary is one thing. Sending the wrong message to a customer is much bigger. The second risk is access. So if a system can open tools, files, websites or accounts, then permissions matter a lot. It should not be allowed to touch everything because it can. The third risk is privacy. So if a system is reading emails, documents or customer data, then people need to know what it can see, what it stores, and where that information goes. Responsible use means setting clear limits. Give the system only the access it truly needs. Keep logs, ask for human approval on important actions, test with safe examples before real deployment. So the more freedom you give an agent, the more guardrails you need around it. So now that we've discussed responsible use, let's move one step further and look at the bigger challenges that show up when the systems start acting more independently. So now that the idea of safety is clear, let's look at the practical challenges people face when building systems that can act on their own for longer tasks. So one common challenge is losing track of the goal. The system starts well, but after a few steps, it may drift into the side tasks or waste time on other low value actions. Another challenge is messy real world data. Websites change, buttons move, and file formats are different. A third challenge is deciding when to stop. Some systems keep trying for too long, others stop too early. Designing that balance is harder than it looks. Along with which comes a challenge of trust. Many people find these systems exciting, but they still worry about accuracy, monitoring, and control. There is also cost and performance. There are more steps, more tool calls, and more checks along with more memory, which can make the system slower or more expensive. This is why thoughtful design matters. So now that we've looked at the real challenges, let's talk about the future because this is the part which audiences love the most. The next wave is not just bigger chat tools. It's a more connected helpers that can work across apps, remember useful context, and support real workflows over time. One trend is multi-step digital helpers. So instead of one answer, people will expect systems to handle a sequence like research, compare, summarize, prepare, and up. Another trend is agents working together. One system may gather information and the other system may review it. A third may prepare the final output. This is especially useful in coding, operations, customer service and research heavy work. Third trend is stronger safety layers. As these systems do more, people are putting more and more focus into permissions monitoring and approval systems. We will also likely see more personal workflow helpers for creators, developers, founders, students, and small businesses. That is why this topic performs so well online. People instantly imagine how it could save them effort in daily work. So the future is not about replacing people with one giant machine. The more realistic future is people working together with digital helpers that can take repetitive steps while humans stay in charge of direction and judgment. So now that we've looked ahead, let's bring it back to the builder mindset and talk about the best practices for making these systems useful and reliable. So now that the future direction is clear, let's talk about how to build well from day one. The first best practice is to start small. Do not begin with a system that tries to do 10 things. Start with one narrow useful task such as summarizing support tickets, checking file updates or collecting product details from a few pages. The second best practice is to define success clearly. How will you know the system worked? Did it save time? Did it complete the task? Or did it avoid mistakes? If success is vague, improvement will also be vague. Third, keep the humans in loop for important actions. Let the system suggest, draft, and prepare, but ask for review before sending, deleting, purchasing, or even changing sensitive data. Fourth, log everything important. If a system is searched, clicked or selected, or someone wrote something for you, you should be able to trace the path later. This is essential for debugging and trust. Fifth, we have design for failure. Assume links may break, tools may time out, or the user requests may be incomplete. Add retries, fallback steps, and clear stop conditions. Sixth, make instructions simple. The clearer the goal, the better the result. Even the best system struggles with the task itself and it's very vague. The best line to end this part with is this. Strong agents are not usually the most complicated ones. They are the ones with a clear purpose, clean boundaries, and steady behavior. So, now that we know how to build more responsibly, let's look at where people can continue learning and stay updated as this space evolves. So, now that we've covered how to build well, the next question is obvious. Where should people go after this session? The best learning path is a mix of three things. First, strong basics in Python. Second, hands-on and mini project. Third, active communities where people share real examples and practical mistakes. A simple browser assistant, a file organizer, a research helper, or a support ticket sortter can teach more than just passive watching. For communities, people can follow Python communities, developer forums, GitHub project pages, and creator YouTube channels that build real demos step by step. These projects are useful because they show what works outside and what works inside. It's also helpful to follow official product blogs and documentation from major platforms because these areas change quickly and new workflows keep appearing. So now that we've covered the best places to keep learning, let's finish with the challenge that turns this presentation into an action. So now that we've covered the full journey, let us end with something practical and motivating. Here is a challenge for the audience. Don't leave this topic as a concept. Build one small working agent in Python. Not a giant platform, not a perfect startup idea, just one useful project. For example, build a system that reads a folder, organizes files by type, or a simple assistant that compares products from a small list and gives a recommendation. You can also build a task helper that can read a request, breaks it into steps, and tracks progress. So, the goal is not perfection. The goal is to experience the full loop. Give the goal, let the system act, review the result, and improve it. Make it safer as well. So we are going to build this demo in a very practical way. Instead of jumping straight into a large project, I will first set up a clean Python workspace in VS Code, install only the libraries we actually need and then test each part one by one. So the libraries that I'm using today are chosen for stability and clarity. So Google recommends the Google Genai SDK as the official Python SDK for Gemini. Langchain's current Google package is lang Google genai. Gymnasium is the maintained replacement for old gym package and the pi autogi installs directly from py pi on windows. So for browser control I'm using selenium because modern selenium uses selenium manager for driver handling and is more reliable for live demos than keyboard only automation. Also I'm using Gemini 2.5 flash instead of the older 2.0 flash variants because Google Gemini documentation shows 2.5 flash as the stable option. So create the project folder and install everything from the VS code terminal on Windows. I will run these commands exactly as showed. So let me go ahead and show you. Let's make directory followed by the name of the file which is Python agent demo. So now that the file has been created, let's move into the file cd Python agent. Now let's go ahead and install Python. So that's pseudoapp install Python. Now let's go ahead and create a virtual environment. So I've done the same using the following command. Now let's go ahead and activate the environment. So for that I will have to type source vnp / bin /activate. Yeah. So now let's go ahead and download all of the libraries. So that's pip install Google genai. So all of the packages have been installed. So at this stage the environment is ready but I still do not want to assume that everything is working. So always make sure that the coding setup is right and also all of your packages have been installed correctly. Now I'm going to add the API key in the safest way possible and that is inside of the root folder. So I will go ahead and create a NV file and then place the key over there. So go back to your terminal. So you can get your API key from Google itself. Just go ahead and look out for um a free API key which Google will provide you with. So we have this. Now let's go ahead and exit. So this file is supposed to stay local to the machine. It should never go into git or be shared in screenshots. So once that is done, I want a simple Python file to check two things. One, if I can read the key properly and two, if I can make a successful call to the model. So before that, I'm going to do two things here. Here we have the requirements.xt file within which I have the list of all the packages which are installed here. So for the people who want to know what packages have been installed for the same thing can go ahead and see. And uh apart from that we have the dot getit ignore file within which these are the contents which have been pasted. So here what I've done is I've created a file called setup check py and this file has been created to check if the setup has been done properly or not. So let's go ahead and type the code for the same. So I have import o. I'll be installing all of the required modules and then from dot go back to our terminal and run it. So I will go ahead and run. So we can go. So since the running went smoothly, you can see a very short reply from the model here saying that the environment is ready and in many cases I will also see the token counts below that as seen over here. So let me go ahead and explain the meaning of this code in simple terms. So the loadn function reads the hidden values from the end file and the os getn fetches the key into python. The genai client function creates a connection object and the client models generate content function sends one small request to the model and finally response.ext prints the answer in the terminal. So now that the environment and the key are confirmed we can move from setup into our first real agent demo. So for doing the same I've created a file called first agent py. So in this program which looks like a situation it picks an action and improves over repeated attempts. So I'm intentionally starting off with a small grid environment because it's very visual and easy to explain and it lets us focus on the decision loop. So the core for the same is as follows. So import random from typing finally end with main. So now let's go ahead and run this file. So this is the command for the same and this is the output we receive. So let me explain the code in simple terms. So the frozen lake version one is a small grid word. So the program starts with a Q table full of zeros and you can think of the Q table as a score sheet. So each row is a state and each column is an action and each cell stores how useful the action has been in that state. So the function choose action here decides whether the agent should try something new or use the best option it already learned and this is what epsilon controls. A high epsilon means more exploration and a lower epsilon means that the agent trusts what it has learned. So inside the train agent function, the agent resets the environment, chooses actions and receives rewards. It also updates the Q table after each move. So the line that updates the table is the heart of learning process. So it takes the old score, compares it with the new result and then shifts the score in the direction of what worked better. So after the training completes, evaluate agent, runs on one test episode using the best actions from the table. So that lets us show the audience the part the agent has learned. So now that we have a basic idea of the decision-m loop, let's make the idea a little more meaningful by clearly explaining the learning step behind it. So we have implementing reinforcement and learning basics. So at this point in the demo, I usually pause and explain that the reinforcement learning is simply trial, feedback, and adjustment. So the agent is not reading a textbook. It's learning from the repeated attempts. So there are only a few values that I need the audience to remember here. So you need to know that alpha controls how fast the agent updates what it believes. Gamma tells how the future rewards matters and epsilon controls randomness which helps the agent discover better parts early on. So the most important line is the update rule. So the update rule is here as follows. So we already had an old estimate of how useful an action was. Then we took that action, we saw the reward and looked at the best future option from the next state and then we combined all of that into a better estimate. The environment interaction happens inside the evaluate agent function which is as shown over here. So this is the part I would like to keep visible on the screen while I explain the output. So as you can see the left, down, right and up over here. So the environment is reset. The agent looks at the current state and chooses the best known action from the Q table. So the environment responds with the next state and the reward. Then the program prints what happened so that we can follow the journey. So now that this is clear, let's move on to the next stage where a program can reason over a user request and choose a useful next step. So with that being said, let's start off with integrating LLMs like GPT for reasoning and context. So up to this point, our agent only learned from rewards in a small grid. Now I want to show you how we can add text based reasoning on top of that. So here, instead of asking the program to move left or right, I'm asking it to look at a real user request and decide what kind of action should happen next. So for this part, I'm using lang chain with Gemini. The goal is simple. Give the model a clear task. Give it the correct context. And then ask it to choose one action from a very small. The goal is simple. Give the model a clear task. Give it the correct context and ask it to choose one action from a very small allowed list. So here is the file and it's called reasoning agent.py. So let me go and download the packages first. So there's import json import OS import. Finish the code like this. So now that the file is ready, we'll go ahead and run the code. Go to your terminal and type python followed by the name of the file. It says that lang google jai hasn't been installed. So let me go ahead and install that first. So let me go ahead and run the code now. Let's see if it works. We have the code running over. So the reason I like this example is that it's very easy to explain. So the model is not going to do everything by itself. It's only choosing from a small list of safe actions that we already define in Python. So that keeps the demo understandable and reduces surprises. So the chat prompt template builds a structured prompt with four pieces. The allowed tools, user goal, the earlier history, and the current state. Then the model returns a tiny JSON object that says which action to take and why. After that, our Python code checks if the returned action makes valid and returns a matching function. So this means that the model helps with reasoning, but the program still keeps control over execution. So now that we have a reasoning step, the next part is to make the prompt clearer and the action flow cleaner. So in the next part I will show you good results do not come from a long fancy prompt. They usually come from a prompt that's clear, narrow and easy to verify. So the key prompt block in our file is this one. So as you can see in this line of the code, you can choose the single best next action from this particular list. So let me explain why this works well for a live demo. First, the system message defines the exact job. Second, it restricts the answer format to JSON. Third, the human message separates the goal history and the current state. And this makes the tasks easier for the model to follow and easier for us to debug. Then we go ahead and create the chain in one clean line. So this is only a tidy way of saying that first build the prompt and then pass it to the model. So then when the result comes back, we pass it, validate it and then continue. So that means our flow is now very clear. We take control of user context, create a clear structured prompt, get one action and run the Python tool. So now that the prompt flow is clean, let me make the assistant feel more complete by adding more memory tools and simple action selection cycle. So at this stage, I want the audience to understand that the memory does not need complicated tools in order to be useful. So for this part of the demo, I will be storing only a short list of earlier actions and tool outputs. So as you can see over here, we have two memory append functions. So now each time the program runs a step, it remembers what it just did. So later when the model has to choose the next action, the memory is included in the prompt as a part of the history. So the tools are also very simple on purpose. So as you can see in the tools part of the code. So the tool is just a normal Python function with a clear job. So one function looks up notes and one estimates the urgency. One drafts a reply and that's all. The action selection is controlled over here. So now the fallback is very important. If the model returns something unexpected, the program does not crash. So it simply picks a safe default. So this is the kind of defensive coding that matters in a live demo which I've showed you here. And remember earlier step we are ready for the final part where we connect a browser based task. So let's go ahead and build an automated AI assistant for web task automation. So instead of automating a random public website that might change tomorrow, I'm going to automate a local HTML page as my browser task target. So that way the demo stays stable and the audiences can still see the full browser automation flow. So first I'll create a simple local page called demo page.html. So I've created a file as you can see it's called demo page.html. Now go ahead and type the following code. So now let me go ahead and create the Python automation script. So when I go and run this so as you can see what this script is actually doing is very clear. So first it asks the model to convert a plain English request into a small JSON object. Then Selenium opens a local page. After that Python fills each field one by one and clicks the submit button. It also reads the result on the page and then prints it back to the terminal. This gives us a full loop. Understand the request, structure it and act on the browser and collect the visible result. So now that the browser part is working, let's make the demo a little more realistic by showing how to handle tasks that require more than one step and may include a feedback. So as you can see over here, this is a simple way to explain the idea. The first line is the original task and the second line is a correction or an extra instruction. So when both go into the prompt, the model returns a complete JSON object and the browser form gets filled with better details. So I would like to make a point here. The model does not directly click anything. It only prepares clean structured data. So the actual browser action is still handled by Python and Selenium. So that separation is what makes the flow easy to trust and easy to debug. Now that we can handle follow-up instructions, the last step is to show how to monitor what happened and to improve the behavior over time. So no matter how simple the project is, I always want a record of how it happened during the run. So this is why I added a small logging function. As you can see, we have the defaf log message function here. So this writes important steps into logs and web agent logs.ext and also prints them into the terminal. During this live demo, this is useful because it shows exactly what the program is throughout the task. So when the page opened, how the browser returned and when the run ended becomes important. So the improvement part comes from three small ideas. First, keep the prompt output structured so that the passing is easier. Second, keep the allowed actions narrow so that the model cannot wander too far. And third, always add a safe fallback in case the return output is not what you expect. So to close the demo, I would say this. We started by preparing a clean Python environment in VS Code. Then we built a small learning agent. Then added textbased reasoning with a control set of actions. And we finally use that reasoning to drive a browser task on a local page. So that gives us a full end to end example. So that brings us to the end of the session on agentic AI using Python. Today we explored more than just a trending term. We looked at a new way of thinking about software itself. Instead of building systems that only respond, we are now learning how to build systems that can take initiative, follow steps, use tools and help move work forward. So this is a major shift and one that is a reason to this topic getting so much attention. So we started with the basics, understood core ideas and looked at how Python fits into the picture. We also explored how these systems can become more practical, useful, and smarter over time. We also touched on safety, responsibility, and the importance of building it in a thoughtful way. So, the biggest takeaway from this session is simple. You don't need to begin with something huge. Start with one small idea. Build one simple working project and test it, improve it, and learn from each version. So, keep learning and keep experimenting.