Click. Ship. Done. AI Agents on Cloudflare

♪♪♪ Hey, everyone. It's really nice to be here to talk about how you deploy AI agents on Cloudflare with just one click. So let me tell you that AI is changing at a rapid speed right now. I mean, you might know this because every week something new is happening or a new model is popping up here and there. So it's really fast-paced right now. To actually understand why this is happening, let's go back in time.

AI was actually coined as a term in 1956, which was a very long time ago. It was more than 70 years ago. After the first chatbot was actually developed, which took two years to develop, there was also Kismet built, which also took two years. Kismet was a robot which had emotions based on what the robot saw. This was achieved by having cameras inside the robot and performing facial or object recognition. Then AlexNet in 2012 was introduced, which was essentially a neural network.

Looking at the timeline, you see that this progress was made over 60 years. The era before generative AI can be referred to as the pre-generative AI era. During this time, access to AI technology was limited to individuals with programming knowledge or those in the field of science and research. However, with the advent of generative AI and the launch of GPT-3 in June 2020, accessibility started to improve. GPT-3 initially had a limited release to those on the waitlist, but it went GA in November 2021. Subsequent developments, like ChatGPT in November 2022, aimed to make AI more accessible to a wider audience, simplifying the programming process and lowering entry barriers.

Only people who knew how to program or basically were in this field for science or basically research. And it was basically just for this group of people. But still, a lot of amazing things happened back in the days, and a lot of things happened now with the generative AI era, with the launch of GPT-3 in June 2020. In this case, it was still in the private beta and not a lot of people had access to it. Only the people who were on the waitlist already had access to it. Soon after, like in November 2021, GPT-3 went GA. But still, in this case, you need to know how to program because it was basically only an API which you have access to. In November 2022, this changed in, you know, with ChatGPT, where nearly everybody had access basically to, basically to ChatGPT. In this case, everybody know basically how to code. You just prompt everything in it and ChatGPT tells you how to program. It was not the best by this time, but it already established a lot of, you know, the first steps on how you do programming. So the entry step was basically way easier than before.

Entropiq launched the first model in March 2023. Google with Gemini soon after in December 2023. And then Zorro was announced in February 2024 by OpenAI, which is basically a program that produces videos based on the user's prompts. And then something interesting happened. There was a thing called agentic loop or iterative loop, which makes the thing for a single pass. I will tell you later what I mean with that. It all started with the launch of MCP in November 2024, maybe a little bit earlier, but around this time. By then, the agentic skills got announced by Entropiq in October 2025. And then one and a half years later, people say that the MCP was dead. I mean, it's not really dead. It's still there. It's still driving a lot of companies and a lot of programs, but people were actually saying it's dead. And then ever since 2026, everything is about agentic coding or basically agentic with everything. So looking at the timeline, it's only six years where a lot of things were evolving and a lot of people actually had access now to how to code or how to do certain things. The thing is, me or a lot of other people have no idea how the future might look like. But what we do know is that just one repository in one program can change the future basically forever, right?

Okay, so looking at single pass and iterative or agentic loop, what is now the difference between these two? Going by single pass, this is what the name already suggests, single pass. So you have a user input.

So you have a user input. Most of the time, for example, in the chatbot, it's a user's prompt. This one goes to the LLM. The LLM basically has everything now then inside and then responds with a natural language kind of thing. In an example, let's assume I write into a chatbot, implement and open a pull request for the first issue I have assigned to me. Now it goes back to the LLM. It processes. It says, sure thing. I will guide you through implementing the issue and opening a pull request. And then there are a couple of follow up questions. So you need to basically guide the LLM to go through it. So again, I'm using a self-hosted instance, and the implementation should be in JavaScript. Again, LLM. Digests everything, prompts it back, got it, and has a couple of follow up questions. So this can take quite a while until you have your pull request basically done.

In the agendic loop, however, this looks a little bit different. So in this case, it's just more steps in between. So you still have to use input. This could be a prompt, an API or whatever. Well, now in this loop, you perceive basically what it was. So it could be again, a prompt, API, whatever. The LLM now reasons about what it got and how it could evolve in the future. Then in the planning step, it actually plans, okay, what could it be and what could it actually be and what are the best steps to process it through. In the act step, it's kind of getting interesting, because at this step, you can basically manipulate the entire prompt by having two calls from MTP like a model context protocol. You can also have API requests, database requests, whatever. You just manipulate how you want to have it. At the fifth step, at the observe step, the LLM basically reasons about, is it already done? And it just gets the bigger picture. If it's not done, it goes in the next loop until it is finished and then has the final response. So if the LLM decides it's done, it gives you the final response. In our example, what we had, if we now give the exact same prompt, like implemented open map request for the first issue I have assigned to me, it now responds a little bit different.

It says, sure thing, but now has three steps. The first step is, look at the issues assigned to you, write code to implement the issue. And the third one, the last one, is to open up the pull request. So it's really going through everything based on what you wrote. So in the loop, the first one, it says, look at the issue assigned to you, done. It has it in the context. The next one says, write code to implement the issue. Once the code is written and code is done, it's actually saying, I will open the pull request. And that's getting smart because what you want to have as a user is you want to have a pull request opened. So the LLM would reason about maybe it's the best to also give a button where the user can basically go to the pull request itself, which is amazing.

So in this case, the agendic loop makes everything smaller or not smaller by meaning of context, but it's making it smaller in the terms of how much you have to prompt to give or to get basically the last result. So it could potentially take longer because you don't get guided through it step by step, but it reasons on its own and this makes everything super powerful. I talked about the model context protocol or MCP in short for a very short second. So for everybody who doesn't know it, this is how our MCP looks like. So MCP is mostly in the form of an MCP server, and it's nothing else than just a normal API server, but specifically for LLMs, which means in this case, if I have an LLM and the LLM says, okay, I have a tool call, it will go to the MCP server, call it, where you register one of those three things, tools, resources or prompts. And then once it receives it based on the API, you can do basically whatever you want.

Once this is done, you have MCP specific output and you return it to the LLM. Most of the time this is in the form of a JSON, but you can do whatever you want. Basically what the MCP allows you to do it. How would it now look like if you would self-host your agent? Well, let's assume you're in a Kubernetes cluster, of course you need to host the Kubernetes, you need to maintain the Kubernetes cluster and so on. But on top of that, you need to have a react application, which runs on Docker. You have an agent, which has basically the agent group, which runs on Docker and on Node.js. You maybe have an LLM, which you self host, which is super hard to do because you need a lot of cheap GPUs, you need distributed data. Most of the time you have this third party somewhere. But on top, you need the MCP on a Docker container and your database. The problem now with that is that we have no idea how the future might look like. We've already seen within six years, a lot of things changed. The agenda group is new for just a couple of months. And who knows what the future will bring? Nobody does.

And who knows what the future will bring? Nobody does. I mean maybe some, but yeah. The thing is now you have to do everything on your own and there are a lot of moving parts, which might slow you down in some parts. You can do it. Of course, please do it, but it takes a couple of times. It just takes a little bit more than it should. So this can be sped up with Cloudflare workers.

On their website, they actually have an example on how you could deploy your AI agent. In this case, this is inspired by Atlassian, where there's an entry point from an engineer, which has access basically in our protocol and then goes through the entire process until it hits basically the website itself. So what is a Cloudflare worker now? So this is the least thing you can have deployed on a Cloudflare worker. This is now accessible via a normal URL, and it's basically just an API. In this case, we return a count of 10, hard coded, but it's a 10. Usually in an API you want to have more interactive and you have a database.

In the world of Cloudflare, this is called a durable object. Of course, you can also have a database, but the durable object is the most tiny thing you can have to store things. In our fetch call, we can actually connect to our durable object and then have access basically to the durable object. In our case, we only connect it and don't have basically access to the state itself. But we can change that by just saying we add a function called increment on the durable object itself. And then on the fetch we call stop.increment, which gives us access to the return value 10.

Again, 10 is not really interactive, but you can make it by just going to the storage itself, say storage.getCount. If the storage.getCount is not there yet, we just default to zero, increment by one, and then store it back into the durable object to persist it and return it again. Which makes in the fetch call, we just call it with count await stop.increment and then return it in the count, which means that every time when we reload, we basically have a new count for basically ever.

So what has it to do now with AI agents or agents itself on Cloudflare? Well, Cloudflare makes it really easy to deploy agents and they have a lot of helping tools. For example, they have an AI chat agent class, which basically extends from an agent, which extends from a server, which extends from a durable object. So everything is built around the durable object because you need to have state stored somewhere. In the AI chat agent case, messages which are received from a chatbot are basically stored in a durable object.

Looking at an example of an AI chat agent on a Cloudflare worker, this is how it could look like, where we basically have the entry point and there's a helper called route agent request where it says, okay, this one goes to durable object or the AI chat agent class. And every time a new chat message is received, you will see the helper tool later, every time when this is received, we can do basically whatever we want. In our case, we make it super minimal by just calling create workers AI, yet another helper function from Cloudflare.

This gives us basically access to every LLM model Cloudflare has access to. Then there's another helper called screen text, where you basically say, this is my model, those are my messages. Please do something and just prompt me a result. Once this is again done, we just stream it back to the user and we are basically done. So in this screen text, there are multiple loops inside, you can steer it however you want, but you can also add more parameters to it. For example, tool calls from MCPs. This .mcp is basically another helper from AI chat agent, where you connect multiple tools to it.

In this case, we just add all the tools we have, which is the reason basically why a lot of people see MCP is that because you bloat the context with just all the tools you have, which adds descriptions and all the names from the MCP tool costs, which is not always the best case, but you can do it. So now you have your AI chat agent and your normal Cloudflare worker fetch response. What to do with that now? You can basically just deploy it with Wrangler deploy, with one code. And once this is done, you just deploy it.

And I show you now how this is actually done. This was one slide too fast, but this is what they actually prepared. So we have now basically a browser application, which has basically access to the Cloudflare worker itself. This is basically deployed on Cloudflare. And this one has now access to MCP server, which we can decide whatever we want. And we also have our self-hosted MCP server, which has access to the GitHub API. The Cloudflare worker itself has, as we saw before, access to a pool of LLMs from Cloudflare itself.

How it looks like is we have two Wrangler conflicts, which is basically the main entry point for Cloudflare. And this is then deployed to Cloudflare. So the app looks like this. We have now signed in to our app itself. Once we are signed in, we basically have access to our AI chatbot. We can do whatever AI agent what we want to have. I showcase the AI chat agent because it's better to visualize.

On the top right, we can connect to any MCP server we want. In our case, to Sentry itself, which is the ProofSeer and InspectIssue events tool course. And now we also have access to another MCP itself. And there are two predefined prompts, which say, please summarize Cloudflare agents. And you can already see that it's getting some two calls from our GitHub MCP, which is our self hosted one.

On the second, basically, the first iteration is it's reasoned about what it needs. It's planning. It got on the next step. It got the two call and then got another round because it was not done yet, because the answer was not finished. It just got the two call on the second round, it reasoned about what it got and then got more of an answer for the user. So in this case, it said, start with almost 5k stars. It has a license of MIT. And this is more information.

So how it looks like now in code. Here we have now our two Rangle configs. In the MCP case, we have basically our source MCP TS, which is stored in here. The main entry point is always the export default, which is what protected. And once we actually protect that, the API handler is the one which is getting caught where we create an MCP handler, which is from a normal from basically from Cloudflare itself. And you can call whatever you want in it. In our case, we have a new MCP server.

And on this one, we just registered different tools. For example, who am I? So if I type in, please tell me who I am on GitHub, it will call this tool because it reasons about this might be the best fit. In our case, we had the get repo info call where our LLM decided that this might be the best fit for the prompt I gave. And once this one hit, it's again, whatever you want in a normal API. So we fetch another API. So in this case, it's the API from GitHub and return an MCP or an LLM suited response. And this is again, a JSON format.

So once this is done, all we're going to do is deploy the MCP with this one command. We just say wrangler deploy dash c wrangler.mcp.jsonc because usually you don't have to define that. But since we have multiple wrangler configs, we just define it. While this one is deploying now, we can look at our agent. We said going back to our when we go back to our example, we just looked at this one. And now we are looking at the second Cloudflare config, which is basically the agent in here, which is say we have EI bindings, we have assets, which is basically our react application.

And we also have the main entry point of the agent itself, which is basically our backend. So we have our app and our agent. Cloudflare provides helper tools for creating a chatbot or agent, like the chat agent. When adding the agent through use chat agent, we can send and receive messages using hooks. The send message function sends text messages directly to the agent. The odd on chat message function allows customization and interaction with MCP and LLM models from Cloudflare.

With just 112 lines of code for the app and 160 lines for the AI chat agent, the setup is efficient. Using the wrangler deploy command, the agent is deployed easily. Automation can be achieved by connecting the GitHub repository to update based on set branches. While the MCP server deployment is in progress, navigating to the agent reveals the MCP server's status.

This streamlined process showcases the simplicity of deploying the agent and app. Integration with Cloudflare's tools enables quick development and deployment. Leveraging the power of Cloudflare, the AI chat agent setup becomes straightforward and efficient. The deployment process, including updates, can be automated for seamless operation and maintenance of the agent.

We say how many times it should iterate. And then we just return it. Once we return it, the messages are getting updated, and we are basically having everything. There's also the status on basically what is basically the status right now, submitted streaming, reading error. This is basically now the loop in our chat agent.

So once this is done and you have done everything, you have just 112 lines of code for the app itself. You have 160 lines of code for the AI chat agent, where here there's the entry point. This is another helper from Cloudflare itself. We just ship it with this one command called wrangler deploy. Theoretically, you don't have to press wrangler deploy; you can also connect your GitHub repository into it.

Everything is done automatically based on the branch you set. In our case, in the meantime, the MCP server was already deployed. Once we are opening this one now, we are seeing the MCP server. Nothing is to do here because our LLM is calling it. You can do whatever you want on Cloudflare. There's the AI chat agent. You can do other web sockets; you can talk to users. You can orchestrate; basically, you can do whatever you want. It's super easy to do it, and there are a lot of documentations on how you do this.