Loop Engineering Guide — Full Breakdown & Transcript

[00:07] do at every step, you could simply give it a goal and let it work through the problem, check its results, fix mistakes, and try again. That is the idea behind loop engineering. Microsoft's 2026 work trend index

[00:19] reports that the number of active agents in its Microsoft 365 ecosystem grew by 15 times year-over-year, showing how quickly AI is moving towards handling more complex tasks. McKenzie also found out that 62% of organizations were at

[00:33] least experimenting with AI agents in 2025. But giving AI the ability to take actions is only a part of the challenge. We also need to decide how it should know whether an action worked, what it should do next, and when it should stop.

[00:46] IBM describes loop engineering as designing workflows that allow AI agents to repeatedly act, observe results, make decisions, and iterate towards a defined goal. Think about a coding task. Instead of asking AI to write code, checking it

[00:59] yourself, finding an error, and prompting it again, the system can be designed to write the code, run tests, examine the result, make corrections, and test again. So, loop engineering is closely related to AI agents, software

[01:11] development, automation, testing, and feedback. But its main focus is the process around AI. It shifts our thinking from how do I write a better prompt to how do I design a better working loop. And as AI moves from

[01:23] simply answering questions to handling longer multi-step tasks, understanding important. Now let's have a look at loop engineering and what it actually means along with why this approach is gaining attention. Before that the agenda. What

[01:37] is loop engineering? Understand the basic idea. Why it matters. See why AI workflows are changing from prompt engineering to loops. Follow the evolution. How a loop works. Understand the work cycle. Core components. Explore

[01:50] what makes a loop work. Planning and execution. See how tasks are handled. Evaluation and feedback. Learn how results are improved. Loop engineering versus prompt engineering. Understand the difference. Loop engineering versus

[02:02] AI agents. See how they connect. AI coding example. Explore a practical example. Real world applications. Discover practical use cases, tools and technologies. Explore supporting tools, challenges and limitations, understand

[02:15] the key concerns, the future, see where it's heading, and finally, key Before we move on, let me share something really exciting with you guys. If you're serious about building skills that can actually help you work with

[02:28] check out the post-graduate certification program in artificial intelligence and machine learning from IDAP IIT BHU Barnasi which is in makes this program interesting is that it doesn't stop your basic AI or machine

[02:44] learning. You get to start with Python, data science, statistics, and machine learning and gradually move into deep learning, NLP, generative AI, prompt engineering, rag, LLM, fine-tuning, MLOps, cloud deployment, and even

[02:56] learning these technologies as understand how the complete AI ecosystem actually comes together. And there's a strong practical side too. You will work with 30 plus tools, libraries and

[03:09] frameworks such as Python, TensorFlow, Langchain, Hugging Face, Crew AI, Autogen and Fast MCP while building 18 plus real world projects across areas like finance, healthcare, marketing, autonomous driving, sales forecasting,

[03:22] AI assistance and more. You also get IIT faculty master classes, Microsoft experience. So whether you're looking to move into AI, upgrade your current technical skills, or understand how today's genai and Asianic AI systems are

[03:35] built and deployed, this program gives you a structured path from the fundamentals all the way to production ready AI applications. So now that we engineering, let's see how well you can identify it. What makes a system a loop

[03:49] engineering workflow? Is it A one AI response, B repeated improvement, C manual coding only, D a longer prompt? Let us know your answers in the comments below. Let's begin with the introduction and why loop engineering matters today.

[04:02] coding tool and you tell it build a login page for this application. The tool writes some code but then the page does not work correctly. You notice an error, explain the problem, ask the AI to fix it, run the application again,

[04:16] discover another issue, and then go back to the AI once more. The AI is helping entire process. Now imagine a different approach where you can define the goal and the system can work through the task, check what it has produced,

[04:29] identify what is wrong, make changes, test it again and continue until it reaches a defined outcome. Now this shift from repeatedly prompting an AI to designing the process around it is what you call loop engineering. Loop

[04:41] engineering is an emerging practice in which developers design workflows that allows AI systems to act, observe results, evaluate their work, and continue iterating toward a userdefined goal with less manual intervention. So

[04:54] IBM describes loop engineering as an emerging practice behind AI coding systems such as claw code and open AI codex. Now this is particularly relevant in 2026 because the conversation around AI is moving beyond simply generating

[05:07] content. Developers are increasingly working with coding agents and other actions instead of responding to one instruction at a time. GitHub documentation, for example, describes an agent loop in which an orchestrator can

[05:20] make multiple model calls and continue using tools until a task is complete. So Instead of asking how do I write a better prompt, we can now ask how do I design a system that can keep working towards the result that I actually want?

[05:35] attempts to solve. Now that we understand why this concept is becoming relevant, let's first define exactly what loop engineering means. So in designing a repeated working process around an AI system so that it can take

[05:50] decision based on what it finds and continue working until it reaches a defined goal. Now the important word here is loop. So think about the way you normally solve a difficult problem. You don't always know the perfect answer

[06:03] attempt, look at what happened, identify what went wrong, change the approach, and then try again. Software development works in the very same manner. A developer writes code, runs tests, sees a failure, check, changes the code, runs

[06:17] the tests again, and continues until the software behaves as expected. Now, loop engineering brings this repeated process into an AI workflow. So, instead of expecting an AI system to produce a perfect answer in one attempt, the

[06:29] several cycles. It can begin with a goal, decide what needs to be done, and determines what should be happening next. IBM defines loop engineering as

[06:41] the practice of designing agent workflows that iteratively guide AI systems towards userdefined goals with minimal human intervention. This does not mean that the AI magically becomes perfect or that humans are removed from

[06:53] is designed so that the useful checks and decisions happen between attempts. For example, if an AI coding system is asked to fix a software bug, the useful process is not simply generating replacement code. The system may need to

[07:07] inspect the relevant files, change the code, run the tests, read the test results, determine whether the change worked, and then make another change if necessary. So the loop is what connects all these actions together. So the

[07:19] engineering is this. Instead of design into AI, we can design the complete process that surrounds the AI. So with the definition in mind, let's understand why the traditional way of working with AI is beginning to change. Now for a

[07:33] long time using AI meant having a conversation. So we would write an instruction, receive a response, review it, and then decide what to ask next. Now this approach is extremely useful for many everyday tasks. But if you want

[07:45] to summarize an article, rewrite an email, explain a programming concept, or generate initial ideas, a simple interaction may be all that you need. The problem appears when the task becomes longer and requires several

[07:57] connected actions. Now imagine asking an AI system to investigate a software problem in a large application. The task may require understanding the project structure, finding relevant files, reading the existing code, reproducing

[08:09] the problem, identify the cause, changing the code, running tests, potentially repeating the process several times. So if a human were to give an instruction for every one of these actions, the AI is still only

[08:22] partially automating the work. The human becomes the person connecting every step together. Loop engineering changes this by moving some of this coordination into the system itself. The AI can be given a goal, a set of rules for how to work

[08:34] towards it and the system can take that and decide what action to take, observe what happened and determine what should happen next. Now this is closely connected to the way modern coding agents operate. IBM notes that modern

[08:46] coding assistants can independently formulate steps, run commands, evaluate results, and iterate before presenting the final output. Now, this does not mean every AI system should operate without a human supervision. In fact,

[08:58] human review can be extremely important when the task has security, financial, legal or production consequences. The important change is that humans do not necessarily need to manually manage every small step. The system can handle

[09:11] the repetitive cycle, but the human defines the objective, sets boundaries, reviews important decisions, and takes control when necessary. So now that we understand why oneshot AI interactions are not always enough for complex tasks,

[09:23] prompt engineering towards this more processoriented approach. Now in order it helps us to look at the progression of AI development. Prompt engineering

[09:35] that the way we communicate with language models can strongly influence the quality of their responses. So now instead of simply asking write code, a developer could be explaining the programming language requirements,

[09:48] constraints, expected output and examples, but the interaction was still instructions. Now the next major development was giving AI access to additional information. Retrieval argumented generation allowed systems to

[10:01] retrieve relevant information from external sources before generating a response. Now, this became particularly useful when AI needed access to company documents, knowledge bases, or other important information. Then came AI

[10:13] agents where systems could do more than just generate text. They could use tools, access information, interact with software, and perform multiple actions. Now, this created a new problem. Once AI can take several actions, how do we

[10:26] decide what it should do next? Well, we also wouldn't know whether an action succeeded or how do we prevent it from continuing when it already has achieved the goal along with how do we recover it when something goes wrong. Loop

[10:40] engineering focuses on these questions and rather than concentrating only on looks at the complete workflow surrounding the model. So, IBM makes a similar distinction. Prompt engineering focuses on creating an effective

[10:53] designs an automated system that can prompt, check and guide the agent repeatedly until the specified goal is reached. So we can think of evolution as a movement from better instructions to better access to information to better

[11:07] ability to taking actions and now to better systems for managing repeated actions and feedback. And this is why loop engineering is not simply a Prompting is still a part of the process and the difference is that developers

[11:20] after the first response. With that evolution in mind, let's now understand what actually happens inside a loop. A loop engineering workflow begins with a goal. But the important part is what happens after the first action. Suppose

[11:34] a developer gives an AI coding system a task. Fix the failing tests in this project. The system first needs to understand what the goal needs. It may which are failing and determine which parts of the code are related to those

[11:47] failures. It then takes actions, perhaps modifying a piece of code. But the loop evidence about whether the change actually worked or not. It can run the tests and inspect the results. And if the tests pass, the system may have

[12:02] evidence and the task is complete. Now, if the tests fail, the result may become a feedback that tells the system that an other iteration is required. Now the system can then inspect the failure, make another change and test again. And

[12:14] this is the basic idea behind an agent loop. Act, observe, decide and continue. Now, GitHub describes its copilot agent loop as an orchestrator that makes one or more model calls and continues the tool use process until the task is done.

[12:29] loop needs a way to determine what actually happened. Without that, the system cannot reliably decide what to do next. Imagine asking someone to keep allowing them to test whether the machine works. They could make hundreds

[12:43] of changes without knowing whether they should get closer to the solution or not. Now, the same problem exists with AI. A useful loop needs actions and observations, but it also needs a clear definition of success. This is why loop

[12:55] engineering is not simply let AI keep trying, but it's about designing a control process where each iteration provides useful information for the next one. Once we understand this basic working model, we can break it further

[13:07] that make a loop reliable. Now, let's move on to the core components of a loop. A well-designed loop needs more than just an AI model. It needs a clear goal, access to right information, the ability to take actions, a way to

[13:21] observe what happened, and rules for deciding what happens next. So, start what it's trying to achieve, and what successful completion looks like. So if the goal is vague, the loop may continue without a clear destination. Next comes

[13:35] context. Now the system needs relevant information to make useful decisions. In a coding workflow, this could include the project files, documentation, configuration, previous changes, and test results. Then comes action. The

[13:47] system needs access to tools that allows it to actually do something in a coding environment. Those tools may include a terminal, file system, version control, testing framework, or other development tools. After an action is taken, the

[14:00] system needs observation. It needs some way to understand what happened and that message, a search result, a performance measurement or a feedback from a user. Finally, the system needs a decision mechanism based on the observation

[14:15] should it continue making another change, ask a human or stop. Now, these components are what turns a simple AI interaction into a working loop. This also explains why simply connecting a language model to tool does not

[14:27] engineering system. The surrounding workflow matters. IBM explains that loop engineering involves designing systems that prompt check and guide AI agents.

[14:39] So rather than simply giving the model instructions one turn at a time, this is what it can do. Once these components are connected, the systems can move one part of the loop that deserves special attention because it determines

[14:52] whether the system is actually making progress or not and that part is evaluation. So let's move on to planning and execution. Before an AI system can determine how the task can be approached. So that is where planning

[15:05] becomes so important. Imagine that someone tells you build an online store. That instruction describes the final goal but it doesn't tell you every would first need to understand the requirements. determine what needs to be

[15:18] built, decide what would happen first, and then start working through those tasks. An AI system operating inside a loop faces the same challenge. It may need to divide a larger objective into smaller actions and decide which action

[15:31] should happen next. So in a software project, for example, the system may first inspect the repository, then identify the relevant files and make a change along with running the appropriate tests. Planning doesn't

[15:43] plan at the beginning and then following it without change. It's a useful loop. In a useful loop, the plan can change when new information appears. And if the system may need to reconsider the original approach. And this is an

[15:58] important distinction because real world tasks rarely behave exactly as expected. Execution then turns the plan into actual work. The AI may use tools to read files, write code, and run commands, search information, or

[16:11] interact with another system. But modern coding assistants are built around this that allow it to work within its environment. IBM describes these tools as essential because a model by itself cannot open files across a term. The

[16:25] therefore allows the system to move from an area to an actual action. But completing an action is not the same as completing a task. The system still needs to know whether what it did was correct. And that brings us to the most

[16:38] important part of the loop. Evaluation and feedback. Evaluation is what tells an AI system whether its previous action was useful or not. Without evaluation, a loop is simply a sequence of actions. With evaluation, the system can learn

[16:51] from the result of each action and decide what to do next. Consider a simple coding example. An AI system is asked to fix a bug. It changes the code and then runs the existing tests. If all the relevant tests pass, that provides

[17:05] the evidence that the change may have to be solving the problem. If the tests fail, the failure provides information that can guide the next attempt. The what changed, and try another solution. And this is a much more useful process

[17:19] repeatedly without checking whether the code works or not. Evaluation can take different forms depending on the task. In software development, it could be automated. You could see compiler errors, static analysis, or performance

[17:34] checks. In a customer support workflow, it could involve checking whether the customer's issue was resolved or whether the conversation needs to be escalated. validating calculations or comparing results against known conditions. The

[17:48] important point is that evaluation should produce evidence. The system needs something concrete that can help it to decide whether to continue or not. Now this is also where human review can become a part of the loop. If the system

[18:00] reaches a decision that requires judgment, it can pause and ask for human approval rather than continuing automatically. VM describes human in loop systems as workflows where people participate in operation supervision or

[18:13] decision-m to improve accuracy, safety, accountability or ethical decision-m. So evaluation does not always mean AI judging itself. It can also involve automated checks and other system external evidence or human reviewer. So

[18:27] once that system receives that feedback, it can decide whether the task is complete or whether another iteration is required or not. Now this brings us to an important question. Why is evaluation so central to the entire idea of loop

[18:39] engineering? The word loop can make the concept sound as though the AI simply repeats the same task again and again. But repetition itself doesn't create improvement. Imagine asking an AI system to write the same piece of code 10 times

[18:52] without checking any of the versions. You would have 10 attempts, but you solution. The difference between repetition and useful iteration is evaluation. Evaluation gives the system information about what happened and

[19:05] whether the last attempt moved it closer to the goal or not. Now, this is why a definition of success. If you're building a website, success might mean that it requires pages work, important tests pass, and the application meets

[19:19] specific requirements. If you're analyzing data, success might mean that calculations are correct, and the conclusions are supported by the data. If you're handling customer requests, success might mean the issue is resolved

[19:31] or appropriately escalated. The clearer the success criteria, the easier it becomes to build useful checks into the loop. And this is particularly important because AI systems can produce outputs that appear convincing but contain

[19:44] mistakes. So a loop may simply ask the same AI system is your answer correct but may not be enough. Better evaluation can involve independent tests, rules, software development, for example, automated tests can provide stronger

[19:59] signals than simply asking the model whether its code looks correct or not. IBM's guidance on agent decoding emphasizes defining clear success criteria providing the right context and logging agent decisions and tool calls

[20:12] so that the workflow can be understood and debuged. So the real strength of loop engineering is not that AI can try again. It's that the system can use evidence from one attempt to make the next attempt more informed. With that

[20:24] engineering directly with prompt engineering because this is where many people confuse the two concepts. Prompt engineering and loop engineering are closely connected but they focus on different levels of AI workflow. Prompt

[20:37] engineering is primarily concerned with how we communicate a task to an AI model. We think about the instructions, context, examples, constraints and that information so that the model can produce a useful response. For example,

[20:51] if you ask an AI model to write a Python function, you might explain what the function should do, what inputs it should accept, and what output it should style you should expect. And that is prompt engineering. Loop engineering

[21:04] asks a much larger question. What happens after the AI generates code? Does the system save the code? Does it run the tests? What happens if a test fails? Or who and what should evaluate the result? Should the system be trying

[21:18] again? when should it stop? When should it ask a human for help? And such questions like that. Prompt engineering mainly focuses on improving the focuses on designing the process that surrounds the instruction. IBM makes

[21:31] this distinction directly describing prompt engineering as creating an effective instruction while loop engineering designs automated systems which can prompt, check, and guide agents through repeated iterations. This

[21:43] disappear when loop engineering becomes important. Prompts can still be a part of the loop and in fact a well-designed loop may contain prompts each used at a difference is that the developer is no

[21:56] during every step. The workflow can determine what information should be provided to the AI and when an other iteration is required. So if prompt engineering is about getting a better answer from AI, loop engineering is

[22:09] about building a process for getting the job done. Now let's have a look on how loop engineering relates to AI agents. AI agents and loop engineering are related but they are not the same thing. An AI agent is a system capable of

[22:23] performing tasks on behalf of the user or another system. It may use tools, make decisions and carry out multiple actions. Loop engineering focuses on how we design the repetitive workflow that guides such an agent towards a goal. A

[22:36] useful way to think about it is to imagine an AI agent as the worker and the loop as the working process around that worker. An AI agent may be capable of writing code, searching information or using tools, but the loop determines

[22:49] what happens before and after those actions. Suppose you have an AI coding agent. You give it a task to fix a failing issue and the agent can inspect the repository, modify files, and run commands. But a loop engineering

[23:01] approach asks additional questions. What should the agent check before making changes? What test should it run afterward? What evidence determines whether the task is complete or not? How many attempts should it be baking? And

[23:13] what happens when it gets stuck? Should it ask a human for approval? So these are the questions about the workflow rather than the model itself. IBM describes loop engineering as an emerging practice for underpinning AI

[23:26] coding agents such as claude code and open AI index. This distinction is useful because it helps understand why simply having an AI agent is not enough. An agent can take actions but without appropriate checks and boundaries. It

[23:39] may make unnecessary changes, repeat mistakes, and continue working after the useful work is finished. Loop engineering gives developers a way to structure that behavior. It provides the conditions under which the agent should

[23:51] act, evaluate, continue, stop, or involve a human. So AI agents give systems the ability to perform tasks while loop engineering focuses on designing the process that helps those systems perform the tasks reliably. Now

[24:04] the easiest way to see this difference is through a real world example. So let's have a look at AI coding. Software development is one of the most clearest examples of why loop engineering matters. So imagine that a developer

[24:16] authentication issue. That sounds like a simple request, but a real software project can contain hundreds and thousands of files, different services, configuration files, test dependencies, and business rules. A coding agent needs

[24:29] to understand the project before it can make a useful change. A loop engineering workflow can begin by allowing the agent to inspect the relevant parts of codebase and understand the problem. The agent can identify the files that may

[24:43] need to change and implement a solution. But the important part comes next. modified code to the developer, the system can run tests and other checks. behavior is confirmed and the workflow may consider the task complete. Now if

[24:59] the tests fail, the failure becomes a feedback. The AI agent can inspect the error, device implementation and run the checks again and this can continue for several iterations. Modern AI coding tools are increasingly designed around

[25:11] this kind of behavior. BM explains that coding agents can formulate steps, run commands, evaluate results, and iterate on their output before presenting it to the user. GitHub similarly documents an agent loop in which an orchestrator

[25:24] makes multiple model calls and continues the tool use cycle until the task is complete. But there is an important engineering principle here. The agent everything without boundaries. The developer needs to define what the agent

[25:38] can access, what commands it can run, which tests determine success, and when human approval is required. Now, this is where loop engineering becomes a genuine engineering discipline rather than simply allowing an AI tool to run

[25:51] repeatedly. Now, the developer is designing the conditions that make the recoverable. From software development, we can now extend the idea into other areas where the task is naturally involving repeated actions and

[26:04] feedbacks. So let's have a look at real world applications. Loop engineering can be useful anywhere a task involves multiple actions, measurable results, Software development is an obvious example, but it certainly is not the

[26:18] only one. Consider customer support. A traditional AI chatbot might answer a customer's question and end the interaction. A more advanced workflow could understand the issue, retrieve the relevant account or product information,

[26:30] suggest a solution, check whether the issue has been resolved and escalate the conversation if the customer still needs help. IBM describes AI agents being used in customer service to resolving tickets, communicating with customers,

[26:44] interactions, and escalate complex issues to human agents. Now, an other example is data analysis. Instead of asking AI to produce one report in a step, a workflow could retrieve the required data, analyze it, check

[26:59] calculations, identify unusual results, revise the analysis, and then prepare the final report. In research, a system could search for relevant information, compare sources, identify gaps, refine the research question, and continue

[27:12] collected. In business operations, monitoring purposes, identifying exceptions, and deciding what action should happen next. The important point is that loop engineering is not tied to

[27:25] just one industry. The pattern can be useful whenever the work naturally observation, and improvement. However, not every task needs a loop. If you ask an AI to explain a simple concept, adding a complicated workflow could

[27:39] create unnecessary overhead. Loop engineering becomes more useful when the task is long, repetitive, difficult to verify manually or requires multiple connected actions. And that distinction is important is not about adding more

[27:52] complexity. It's about adding the right amount of structure for the problem. now look at technologies that can be engineering is not a single software product or framework. It is an approach

[28:06] to designing AI workflows and different tools can be used to implement those usually an AI model capable of understanding instructions and generating decisions or actions. Around that model, developers add tools that

[28:19] outside world. In a coding workflow, these tools may include the file system, term control system, documentation, and issue tracker. In another application, the tools could include databases, APIs, search systems, business software, or

[28:33] customer records. Modern coding systems such as clot code or openi index are examples of tools that can operate within this broader agent loop approach. IBM specifically identifies claude code and openi index among the AI coding

[28:46] systems underpinned by loop engineering. Frameworks can also help developers build these workflows. Tools such as langraph can be used to structure stateful multi- aent steps while other agent frameworks provide different

[28:58] approaches to coordinating actions and decisions. The important thing is to remember that the tool itself does not automatically create a good loop. A developer still needs to decide what the goal is, what information the system

[29:10] should access, which tools it should use, what counts as success, how errors should be handled, and when humans should become involved. In other words, technology provides the building blocks, but the workflow design determines how

[29:23] those building blocks work together. And this is why two systems using the same AI model can behave very differently. One may have clear success criteria, sensible stopping conditions, while another may simply keep generating

[29:36] outputs without any meaningful checks. Now that we know what technologies can understand the future of loop engineering. So, let's move on to that. concept. So, it's difficult to say exactly how this practice will develop

[29:51] over the next few years. What is already clear, however, is that AI systems are moving towards longer and more complex workflows. Developers are increasingly working with systems that can use tools, modify software, perform tests, and

[30:03] continue working across multiple steps. IBM now describes loop engineering as the emerging agentic AI engineering practice that connects it directly with modern AI coding systems such as claude and codeex. Now this suggests that it is

[30:17] an important skill for developers which can increasingly help grow the ability works. Rather than simply writing instructions for individual interactions, developers may need to spend more time defining requirements,

[30:31] creating tests, setting permissions, designing feedback mechanisms, maintaining project context, and deciding where human approval belongs. In other words, the developers role can move further towards designing the

[30:43] does not mean that traditional programming disappears. It's quite the opposite to that. As AI systems become capable of producing more code, the understand architecture, test behavior, review changes, and maintain reliable

[30:58] systems becomes even more important. Loop engineering may therefore become an other layer of software engineering rather than a replacement for it. We can also expect much more attention to areas such as a persistent state, evaluation,

[31:11] monitoring, cost control, security, and recovery. Now the more independently an AI system can act, the more important these engineering controls become. The central idea is simple. If AI is going to work on longer tasks, we need better

[31:24] ways to manage the work between the first instruction and the final result. And that is the problem loop engineering is attempting to address. So before we finish, let's bring all of these ideas together and summarize what you should

[31:36] here are the key takeaways. Loop engineering is fundamentally about changing the way we design AI workflows. Instead of thinking only about the think about the complete process that allows the system to work towards a

[31:50] goal. We define what goals needs to be achieved. Give the system the Allow it to take actions, check what happened and use the results to decide what should happen next. The most

[32:02] important idea is that repetition alone is not enough. A useful loop needs evaluation and feedback so that each iteration has a purpose. This is also what separates loop engineering from simply asking an AI to try again. Prompt

[32:15] engineering focuses on improving the instruction given to an AI prompt. While the larger workflow around that model. AI agents provide the ability to perform a way to structure and manage those

[32:28] Software developments provides one of the clearest examples. An AI coding system can inspect a project, make a change, run tests, examine the result, fix problems, and continue until the defined success criteria is met. The

[32:42] same general idea can apply to research, customer service, data analysis, and other multiplestep workflows. At the same time, loop engineering introduces challenges around reliability, cost, security, permissions, evaluation, and

[32:56] human oversight. So, the goal is not to remove humans from the process. The goal is to build better systems in which humans define objectives and boundaries as AI systems continue moving from answering questions towards completing

[33:08] design these loops can become a much more important part of modern AI engineering. And that is the key idea to remember. The future is not only about building smarter AI models, it's also about building smarter systems around

[33:21] them. And that brings us to the end of this tutorial on loop engineering. We saw how AI workflows are moving from simple responses towards systems that can act, evaluate, and improve through repeated cycles. I hope this helped you

[33:33] understand the concept, where it can be used, and how it's useful in the real more such insights, and check out our related videos.