All language subtitles for What is OpenClaw Inside AI Agents, LLMs and the Agentic Loop [English] [DownloadYoutubeSubtitles.com]

So here's the thing, we've all been using AI chatbots, right?

Where you as a user will go ahead and give your question to some type of LLM that's running, your favorite GPT or Claude model, perhaps,

and get that as an answer back from the large language model that we have over here.

He's real happy to see us.

Now, the thing about this is that

maybe it helps respond to an email that we have.

So we pull in and copy paste information from Gmail or we need help scheduling a meeting.

So we're pulling in calendar availability, but you're the one doing the actions.

You're copy pasting information, you're switching tabs, clicking buttons, and you're putting this all in the context window of that prompt to the LLM.

Now I could ask my favorite LLm to schedule me this meeting and it'll tell me exactly how to schedule it.

But the thing is, it's not actually going to go to my calendar and schedule that meeting for me.

So that is the gap between knowing and what we're gonna be talking about today, which is doing,

where by connecting these large English models with tools,

we're able to create an AI agent to solve these problems that typically humans are having to move information back and forth and use tools ourselves

and being able to run that autonomously with agents such as OpenClaw.

Now, how OpenClaw works is quite interesting.

We're gonna be talking about it today, as well as some real use cases and security considerations for enterprise readiness, but welcome to the world of AI agents.

Let's quickly start with the fundamentals because an AI agent like OpenClaw

is a system that combines a large language model with the ability to use tools and to take autonomous actions.

And while a chatbot interaction is typically a user sending a prompt and a model generating a response,

An AI agent is fundamentally different operating in what's known as an agentic loop.

So let's take the case of OpenClaw.

Now, how this works is typically a task is going to come into the agent, right?

So this task could come from a variety of different places.

Maybe it's an organization that's running OpenClaw and connecting it to their Slack.

Or maybe it's iMessage if you're using it.

On your own device or WhatsApp, some type of communication platform to talk to our agent.

But from there, that's where the real magic of this AI agent begins.

Because the AI agent then begins to assemble the context that will be passed to the LLM.

So this is the conversation history, it's the long-term memory, it's this system instructions,

and what's most important is also the available tools that the model can use if it needs to pull in additional information.

To answer that first request or that initial request from the user.

So the next step is it's going to send that accumulated context to the LLM to perform reasoning.

So the model then decides, hey, do I need to use a tool to pull in data for my response?

So we'll come down here and we'll say, hey.

Do we need to a tool?

And if we do need to us a tool, Then, that's when we might need to pull in...

Additional information from, say for example, a terminal command, to read a file that we have on our hard drive, to search the web, to call an API.

And when that tool is executed, the agent then receives the result and that information is passed again to the context window that we had originally.

So all of that existing information plus the result of a tool call that we did here.

Now, let's say that this loop continues of reasoning, acting, and observing here until the task is done.

So if we don't need to use a tool anymore, then we can come down here.

We can say no tool is needed.

And that final response is then going to be taken and passed back to the user here that is also communicating through Slack or iMessage, that initial platform.

And here...

This is what's called the React Pattern.

So we are essentially reasoning over our information that is provided from the user and provided from different systems connected to the agent.

And then we're also acting on that information.

And that, my friends, is the core pattern behind every agent framework out there.

Now, let's take a look at OpenClaw because it's probably the best real-world example of an agentic AI assistant in action right now.

OpenClaw is a free open source AI agent that was created in late 2025, but now it is one of the most popular projects on GitHub by total stars.

So let's learn how it works.

So the OpenCLAW agent runs on a local Node.js service on your machine.

So this could be your laptop, a virtual machine, a Raspberry Pi, wherever you want your personal assistant to be available.

Now it follows a hub and spoke model that's centered around one singular part, which is called.

The gateway.

Now the gateway is really important.

It's a control plane and it's always on as a WebSocket server that handles things like message routing,

session management, the ability to create multiple agents, and as you'll see in a second, the usage of tools.

But how do you actually communicate and access this main gateway?

Well, there's two methods, including the UI and the CLI to actually manage the gateway,

but when you're sending requests to your agent, you have messaging integrations through various channels.

So these are going to include examples like Slack and Teams, as we talked about before,

but also Discord, iMessage, pretty much any kind of communication platform that you wanna reach your agent with, you can.

But the way that is actually standardized to something like OpenClaw is through these different adapters.

So the adapter takes in these different types of incoming sources of data into one unified internal format that can then be provided to that gateway.

Now we talked about the agentic loop that is used to assemble the full context of a request before it's actually passed to our LLM over here.

So the LLm for open call could be a model that's running locally on our or something that's hosted when we're sending data.

From outside of our local system to an API.

But this LLM is going to need not just the request from the user, but additional data.

And this could come from different databases that could store long-term memory about the conversations and the work that our agent has been doing.

So this data will be passed through the main central gateway, along with other information like prompt templates and the agents.md and sole.mdi.

That are markdown files that decide how the agent responds and what the agent's job is.

And we'll talk a little bit about that when we come to this skills and execution layer at the bottom.

So when we go down one more layer, we've got the ability to use tools.

And this is really where we can craft our agent's capabilities.

Now there are capabilities such as the ability to use a web browser to automate different tasks for us, which is really cool,

or to use the terminal.

So if we need to run commands or access different CLIs, there are built-in tools with OpenClaw in order to do that.

The skills are what makes OpenClaw extensible as an AI personal assistant.

And they're essentially just folders that contain a markdown skills file

that contain instructions to teach your agent how to perform a specific task or workflow to help you out.

And what's cool is that OpenClaw doesn't automatically give all of this information to the model by default, because it would fill up that LLM's context window quite quickly.

Instead, it injects the available skills and some brief metadata so that the LLm can pick what would be useful for a specific task and can read that full skill on demand.

And there's thousands of skills out there to manage everything from, say for example,

using Trello boards and being able to update that, or for example Google Calendar, being able access and edit calendars.

But also for engineers, for example, being able to use Docker to build, run, and test container images,

or even say, for example, to connect to CRMs, GitHub, different types of data sources.

And we're teaching the model how to perform these functions that we would typically do

to use the agent to automate whatever you need, whether it's on demand when you're using one of these integrations up here.

To use Slack or iMessage to talk to the agent, or even set up automated cron jobs to run these tasks whenever you need.

Before you go all in though, let's talk a little bit about security with OpenClaw because with great power also comes great responsibility.

Since OpenCraw runs locally and has access to your file system, your terminal and other integrations,

a misconfigured environment could also essentially lead to a powerful backdoor on your own machine.

And there are thousands of internet-explosed open-claw instances out there already just due to misconfiguration or skills that might contain malicious code.

And that brings us to the second thing you should watch out for, which is prompt injections.

This is a typical vulnerability with LLMs where the agent processes an untrusted input,

like an email or a web page, and there's malicious instructions that might be embedded in that data.

And the LM might execute them thinking that they're legitimate commands.

It's also important with AI agents to run them in an isolated environment,

to also review the code and skills that you run

so that you don't run into various types of bugs and make sure that you also encrypt your credentials before sending them to an LLM.

So for years, AI has just been a conversation where you talk back and forth to a model, right?

Our interactions were simply conversations with an LLLM, that could tell us what to do, but not actually help us do it.

Now our interaction has changed where the AI model essentially becomes the orchestrator

and is able to do those tasks that we need being able to plan, execute, and observe until that loop has been finished.

Now with the open source, open call project, this represents just of one approach to.

Solving challenges with AI agents.

But there are tons of frameworks out there to build agents like LandGraph and others, and there's no denying OpenClaw's momentum.

Now, the patterns you've learned today are applicable to all types of AI agents,

but remember to be responsible when it comes to security, governance, and deployment practices as well.

So what do you think?

If you have questions or comments about AI agents or OpenCLAW or anything we've covered today, feel free to let us know in the comment section below.

And don't forget to like this video if you learned something and subscribe for more in-depth content on AI and beyond.

Thanks so much for watching.