Big Idea

The argument in one line.

You can build a free 24/7 autonomous AI agent using PopeBot, local open-source LLMs, and GitHub Actions that requires no API fees or expensive hardware.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

A developer or technical founder who wants to run autonomous AI agents continuously without paying $100/day in API fees or buying expensive hardware.
Someone already using Ollama or Docker locally who's curious how to connect those tools into a production agent architecture that works 24/7.
A person frustrated with expensive AI agent platforms like OpenClaw or Claude who has a computer already running and wants a free, self-hosted alternative.

SKIP IF…

You're non-technical or uncomfortable with Docker, command line, and local LLM setup — this assumes you can handle infrastructure.
You need a polished, no-code solution — PopeBot requires some technical configuration and troubleshooting beyond a single-click install despite the name.

TL;DR

The full version, fast.

PopeBot is a self-hosted autonomous AI agent that runs continuously on hardware you already own, using free local LLMs through Ollama instead of paying $100-a-day API fees or buying a $500 Mac Mini. The architecture combines Docker containers (event handler, reverse proxy, GitHub Actions runner) with a Git-backed control layer, so every change the agent makes to its own code, cron schedule, or skills is tracked, reviewable, and optionally gated behind manual approval. A web chat interface, scheduled heartbeat, API endpoint, and Telegram bridge all feed the same job swarm. You install it with one npm setup command, point it at Ollama plus an ngrok tunnel, and scale horizontally across machines or GitHub's 2,000 free runner hours whenever you outgrow local.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:32

01 · Hook + villain frame

Binary-rain open, names expensive guru setups as the enemy, promises free alternative + one-step install

00:32 – 01:41

02 · Web chat interface demo

Tour of new PopeBot web UI: chats, swarm monitor, notifications, upgrade, settings, cron jobs

01:41 – 02:28

03 · Heartbeat scheduler

Heartbeat as the autonomous core -- scheduled instruction loop driving all agent tasks

02:28 – 03:42

04 · Live chat demo with Ollama

Types instruction to update heartbeat to 10 min; agent executes via GitHub runner in real time

03:42 – 05:21

05 · Swarm + change approval

Job queue, GitHub Actions link-through, PR-based approval workflow, rebuild fires on approve

05:21 – 07:01

06 · API + Postman + auto-upgrade

API key generation, Postman job submission outside chat, one-click upgrade to v1.2.67

07:01 – 09:01

07 · Heartbeat output + install intro

Weather task result in /job/WEATHER.txt; agent capabilities; GitHub README 3-step overview

09:01 – 11:23

08 · NPM install + GitHub token

npx my-agent; npm run setup; repo creation; fine-grained PAT with required permissions

11:23 – 13:27

09 · LLM config + ngrok

Ollama local Docker URL, model selection, Brave Search add-on; ngrok http 80 for home firewall bypass

13:27 – 15:52

10 · Docker launch + first login

docker compose up, four containers, Docker Desktop check, admin account creation, first message to local LLM

15:52 – 18:25

11 · Docker architecture explained

Three containers: event-handler (bot brain), reverse proxy (SSL), runner (job executor). Whiteboard sketch. Scalability to multiple cloud servers.

18:25 – 20:11

12 · Git transparency + auto-merge

Every agent action is a commit/PR; full audit trail; path-based auto-merge rules; config editable from GitHub UI

20:11 – 21:03

13 · Roadmap + community CTA

More skill examples, self-learning, more chat platforms, GPU video. AI Architects Skool community plug. Outro.

Atomic Insights

Lines worth screenshotting.

A fully autonomous AI agent running 24/7 on your existing hardware is achievable with Ollama, Docker, and GitHub Actions — all free.
The heartbeat is the core of any autonomous agent system — a recurring interval task that checks email, does research, and executes standing instructions.
Using GitHub as execution infrastructure means every agent action is version-controlled and reviewable before being applied to your running system.
A one-step install that auto-provisions the entire stack removes the biggest adoption barrier for self-hosted autonomous agents.
GitHub runners provide free compute for scheduled agentic jobs up to the free tier limit, making cloud execution cost-zero for light workloads.
An auto-update mechanism that pulls new versions through the same agent approval flow means the system can upgrade itself without manual intervention.
Approval-gated changes — reviewing agent edits before they apply — give you full observability without blocking the automation loop.
The same agent architecture that runs on a local computer can be scaled horizontally by adding more runners in the cloud without code changes.
Running free local LLMs via Ollama eliminates API fees entirely, making the cost of autonomous agents a one-time hardware decision.
Notifications for every agent action appear in the control center dashboard, so monitoring does not require visiting GitHub directly.
A Telegram interface is an alternative to a web chat UI — both pipe jobs into the same swarm execution layer.
An API endpoint on the agent system lets external tools submit jobs programmatically, turning the autonomous agent into an addressable service.

Takeaway

The villain frame is the whole video.

Self-host content playbook

Name the expensive thing first, name it specifically, then show your free alternative live -- the demo only lands because the villain was established in the first breath.

Open with the exact cost the audience fears paying -- specific dollar amounts ($100/day, $500 Mac Mini) are far more visceral than vague references to being expensive.
Lead with your most polished UI even in a CLI tutorial -- the ChatGPT-like web interface is what makes the free claim feel credible.
Frame your implementation constraints as transparency features: Docker = security, GitHub commits = audit trail, PR approval = human control.
The heartbeat is a teachable named primitive -- reuse it in your own automation content as a concept you can own.
Star-the-repo ask mid-tutorial (8:00) outperforms a cold CTA at the end -- ask when trust is highest, not when attention is lowest.
Whiteboard diagrams drawn live signal deep understanding and create a visual anchor the viewer can screenshot.

Glossary

Terms worth knowing.

Autonomous AI agent: A software program powered by a language model that runs on its own schedule, takes instructions, and performs multi-step tasks like research, scheduling, or sending messages without a human driving each step.
API fees: Per-call charges that providers like OpenAI or Anthropic bill when software sends requests to their hosted models. Heavy agent use can rack up these fees quickly because every action triggers a model call.
Local LLM: A large language model that runs on your own computer instead of a cloud provider's servers. Once downloaded, it answers prompts offline with no per-request cost.
Ollama: A free tool that downloads and runs open-source language models locally on Mac, Windows, or Linux, exposing them through a simple API other apps can call.
Docker: A platform that packages software into isolated containers so each program runs in its own sandboxed environment without conflicting with the host system or other apps.
Docker container: A single running instance of a Docker-packaged program, isolated from the host machine and from other containers but able to talk to them over a defined network.
Docker Compose file: A configuration file that defines a multi-container Docker setup, listing each container, its settings, and how they connect, so the whole stack can be started with one command.
GitHub Actions: GitHub's built-in automation system that runs scripted jobs called workflows whenever you trigger them or on a schedule. It includes a free monthly allotment of runtime.
GitHub runner: A worker machine that executes a GitHub Actions job. It can be GitHub's hosted infrastructure or a self-hosted machine like your own computer.
Repository (repo): A project folder tracked by Git and hosted on GitHub, containing the code and a full history of every change made to it.
Heartbeat: In agent frameworks, a recurring trigger that fires the agent on a fixed interval (for example every ten minutes) with a standing set of instructions to carry out.
Cron job: A task scheduled to run automatically at a set time or interval, named after the long-standing Unix scheduler.
Reverse proxy: A server that sits in front of other services, accepts incoming traffic, and forwards it to the right backend. It commonly handles HTTPS certificates and routing.
SSL certificate: A digital credential that lets a website serve traffic over HTTPS, encrypting data between the browser and the server and proving the domain's identity.
ngrok: A service that creates a secure public URL pointing to a program running on your local computer, letting outside traffic reach it through your firewall. A free tier is available.
Firewall: A network barrier, often built into your router, that blocks unsolicited incoming connections from the internet to devices on your home network.
NPM module: A reusable package of JavaScript code published to the npm registry that other projects can install and run with a single command.
API key: A secret string that identifies and authorizes a program when it calls an external service's API. Keys are usually scoped to specific permissions.
Personal access token: A GitHub-issued credential that lets scripts and tools act on your account with a limited set of permissions, used instead of a password for automation.
Postman: A desktop tool for crafting and sending HTTP requests by hand, commonly used to test APIs without writing code.

Resources

Things they pointed at.

00:00productPopeBot / OpenClaw ↗

01:40toolOllama ↗

12:23toolngrok ↗

11:30toolBrave Search API ↗

20:51productAI Architects (Skool community) ↗

Quotables

Lines you could clip.

00:00

“AI gurus are pushing expensive setups with Cloudbot that cost a $100 a day in API fees and $500 Mac minis.”

Pure villain frame -- specific dollar amounts, competitor named, no setup needed→ TikTok hook↗ Tweet quote

05:42

“This is completely and 100% scalable. From this control center, we can be running one, two, 10, hundreds of these processes all at the same time.”

Escalating number sequence lands the scale promise cleanly→ IG reel cold open↗ Tweet quote

18:29

“We are not just setting up an agent that is able to modify itself with no transparency, with no way of knowing what is happening or tracking it. We have that.”

Addresses the #1 fear about autonomous agents in one sentence→ newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

metaphoranalogy

00:00I built an autonomous AI agent that runs twenty four seven on any task you give it, completely free on a computer you already own using free AI models. AI gurus are pushing expensive setups with Cloudbot that cost a $100 a day in API fees and $500 Mac minis.

00:15And most people are missing the biggest shift of their lifetime because of it. It took me weeks to figure out the right architecture, but I finally cracked the perfect setup. In this video, I'll show you a live demo and walk you through the one step install.

00:26Then I'll explain exactly how this works so you can have your own free agent running before before this video ends. Let's get into it. Alright.

00:32I'm gonna start with the new web chat interface, then I'll get into the one step install with the free LLMs. You can see I'm running Olama here locally on my computer, then we'll finish out the video. If you saw my last video, you'll see that I did a demo using Telegram, which you can still use, but I have this beautiful new chat interface that I'm gonna walk through now.

00:50So I'm gonna go through a full example here, but I'm gonna go through the sidebar here and give you an introduction. It's gonna feel a lot like what you're used to if you're using OpenAI or Cloud. Start a new chat, you can view your existing chats.

01:00Here you can check out your server swarm where all of your different jobs are running, where you can get access to statuses and where they are. Any notifications that are coming back into the system, you can see them here. And this is brand new as well.

01:12When I upgrade the system, it's very easy for you to update. You can come here and just click update and it will auto update to the next version. A link to get support, all your old chats, and then we've got settings down here.

01:23You can report bugs right there. You click on settings, it's gonna take you and show you all of your cron jobs. This is all of your scheduled jobs that are running.

01:31You can also set up triggers so as certain events happen, you can trigger events in other applications, and then you can set up your secrets for your API keys. Now let me show you an example. One of the most important parts to your autonomous agent is the heartbeat.

01:43If you've used Cloudbot or OpenClaw, you'll be familiar with it. It's really just the place where you put in all of the instructions for your assistant that you want to run on a regular interval. Right now, it is set to thirty minutes, but it is disabled.

01:55And this is where you're going to have your agent doing your research or checking your email or scheduling calls for you, whatever that might be. And so since it's disabled, we're gonna head over to the new chat. And keep in mind that this is all connected to Olama.

02:08So this is all running for free. I'm not paying for any of these API calls. Please update the heartbeat to run every ten minutes and also enable it.

02:22So we'll just do something simple like that. It's It's gonna go ahead and think about that job and prepare an actual job. And then you'll see here it's actually doing the the streaming chat which is pretty cool as well just like all the other AI companies do and it looks like it created the job.

02:34So now if we come over to the swarm here, we're gonna be able to see that it's actually running here. And I'm gonna go over the architecture in more detail in just a few minutes, but hang with me because I just wanna walk you through this process and I'll explain all the details and the why behind everything as we go. Now these jobs are using GitHub runners and I'll explain more about those as we go.

02:53But if you click through to it, it is gonna take you to GitHub and it's gonna allow you to actually see everything that's running. And you can do this all on GitHub for free. So you can actually watch the job complete here or of course, you can just monitor it straight from here as well.

03:05This is gonna automatically refresh and keep everything updated. It keeps a history of everything and it's all paginated so you can check everything out. Now real quick, I wanna show you this here and I'll explain more detail and how you can configure it later.

03:18But all of the changes by default that the agent makes will be done in a way where you can monitor it and even approve it. If you don't want to approve all of the changes to your system that the agent is making, you can turn that off. But by default, it's giving you the ability to review everything that's happening.

03:34Here you can see it's making these changes. It turned the schedule from 30 to 10 and it enabled the cron to run. By using GitHub, we have this ability to actually track the changes that are being made and even approve them.

03:46So I can come here and I can approve it. And once I approve this, then it will actually automatically update my running PopeBot right here.

03:54So you can see right now, as soon as I did that, it's running the rebuild event handler, which is gonna pull down the code and automatically update everything here. And again, if you ever wanna see what's going on, you can always just click view. It's gonna take you right to the right place and you can just watch everything that's happening.

04:08So here we can see we have a success and we're also getting notifications as well. So even though I'm showing you what's happening in GitHub, you don't really have to go there. Everything happens here in the control center.

04:19We can come to notifications here and we can see we successfully updated the heartbeat. We moved it from thirty to ten minutes and we enabled it from false to true.

04:28And if we come back to our settings here and we come to the cron, you're gonna see here that the heartbeat is now running every ten minutes and it is now enabled. If you do wanna use the API, you can come here and get your API key. I'll go ahead and regenerate it.

04:42I can go ahead and copy this. And if I wanted to send a job directly into the system, I'm here in Postman, which allows me to simulate an API call. It's as simple as sending a payload where you give it the job and you tell it what to do.

04:54And all the instructions on how to do this is on the GitHub page that I could just put in the key value here. I could say disable the heartbeat cron and move it back to thirty minutes.

05:08So if I do that, I can just send it just like an API call. So if I wanna do things from outside the system and not in the chat and so that's just gonna go through the same process that we just went through except it's going to disable the heartbeat and turn it back to a thirty minute interval. Oh, and let me show you how the auto upgrade works.

05:23This works the same way as everything else. Everything is very consistent. You come here, it shows you what version is available, what version you have.

05:30You just click upgrade, it will go ahead and trigger the process. And just like everything else, everything's running through your swarm. This is managing all of the different jobs that you are running.

05:39And just keep in mind that this is completely and 100% scalable. So from this control center, we can be running one, two, 10, hundreds of these processes all at the same time.

05:50And we can run them on our local computer or we can run them in the cloud. In fact, you can also run them inside of GitHub for free up to a certain amount.

05:59So this system has been carefully architected to be very scalable and also conscious of those that want to make everything free or those that want to invest more money and make it more powerful, faster, and scale well beyond what you can do on a single computer. So it's flexible for everyone.

06:17So we can see here that the upgrade event handler ran successfully. So it's actually rebuilding the system underneath us as we use it. And then you can see here we're on one point two point six seven and we upgraded.

06:28So if we do a refresh, we're now fully updated and we've got all of our notifications. By the way, I do wanna show you this notification here when we did update the heartbeat to run, it actually went ahead and did that.

06:39And in my example heartbeat, I just had it grab the weather here and you can see here it went ahead and did that task and finished it and put it inside of this text file here which exists on the system which you can use with any other scheduled job that you create. And of course, there's much more powerful things that you can do than just getting the weather.

06:56The agent can write code. The agent can create its own skills. The agent can call APIs.

07:01Anything that you can think of. Alright. So now let's jump into how to actually install the PopeBot.

07:07The link to this repository is in the description below. If you scroll down, you're gonna see the getting started directions. There's only three simple steps that you have to go through and it's gonna walk you through every single one of them.

07:17There are some things that you have to have installed ahead of time. I've got easy links for everything. You only need this particular program if you're running this on your own computer.

07:26So I'm gonna go ahead and open up a terminal here and I'm just gonna walk through it with you the same way you would. You can go ahead and just copy this here. Go ahead and paste right into your terminal.

07:35Now, have not tested this on PC, if it's not working, go ahead and let me know and we'll get you sorted out. Now, if you use the POP Bot before, it used a mechanism called forking which I abandoned. And now we have an official NPM module, so it makes it a whole lot simpler.

07:47It's gonna download that. Just go ahead and click yes. It's gonna get everything ready.

07:51And there's also a lot more information on this page as well that will tell you more about how the POP Bot works. Also, make sure that you star this repository so we can get it out to more people. You can do that by coming right here and just hitting star.

08:02Make sure you do that right now. Now from here, all you have to do is type npm run setup.

08:07Gonna go ahead and name your project. It's gonna default to the current directory name. Now we have to create your own repository to store all of the code so that as it's updated, it's keeping track of all the changes.

08:18So you can go ahead and just click yes. It's gonna open up a page. All you have to do is just create the repository.

08:23Now the next question it's gonna ask you is it's gonna want this link, I'm just gonna grab it now. But if we come back, you're gonna see it's asking for it right here. I'm gonna just paste that in there.

08:32Now in order to automatically set this up, we do need an API key from GitHub. If you just click yes, it's going to open up that page for you. Now down here, what I recommend is only giving permission for this key to access this particular bot.

08:45So we'll click my agent. Now we do need to add some specific permissions here and that is all listed here. I'm just gonna move this off to the side so I can add these easily.

08:54Actions, administration, contents, metadata is already set, pull requests and workflows and they all need to be read and write.

09:08That should be good. You can go ahead and generate your token. Now we just need to take this, copy it back to the install and just paste it right here.

09:15Now here's where we set up the LLM. You can use any LLM you want but I promised you free so I'm gonna show you the local setup. Go ahead and click local.

09:23It's gonna ask you for the API base URL. So a lot of the free LLMs that you install in your computer like Olama, they will provide you an API.

09:31And you need that URL in order to make this work. I have an Olama example here. Because we're using Docker and I'll explain that architecture in a minute, you do need to use an internal Docker URL and I provide that right here in case you're using Olama.

09:44So I'm just gonna grab this. Looks like it's already here but we'll do that.

09:48We're gonna pick the model. I've been experimenting with different models, but we're gonna go ahead with the default. Just paste that in there just like that and then you don't need an API key if it's local.

09:56Now it's gonna ask if you want to use the open API key for voice messages. This is more for Telegram when you're actually sending out voice messages like this. I'll show you where the setup for Telegram is, but I'm gonna go ahead and continue with this for now and I'm gonna go ahead and just say no.

10:11It's also gonna ask for Brave Search. This is a service that will allow you to do something similar to Claude's web search. There is a free account and it will greatly improve your agent's ability, I'm gonna go ahead and click yes.

10:22Again, just like everything else, it's gonna go ahead and open up the page for you. Just log in, create your free account, create your free API key, and you can drop this in as well. Then it's gonna set everything else up for you, all of the secrets.

10:33And now here's the part that's important. If we are using this on our local computer, there's a tool that we can use called ngrok and there is a free account as well. And basically the way it works is that when you're using your home computer, there is a firewall here sitting in front of your computer that makes it impossible for everything that's going on, all of the notifications to reach you.

10:53So what this does is it sets up a connection with ngrok and your computer so that things can connect here and then the communication can go through. If you set this up on DigitalOcean, you won't need to do that. You just use your DigitalOcean URL and you put that in there and you'll be good to go.

11:08So I already have ngrok set up and just so you know the way I start it is I just type ngrok http eighty. That's all you need to do.

11:16It's gonna load up. You will need to create an account of course and I think there's some sort of token you need to set up but it's super easy just follow their instructions. You come back here, drop it right there, it's gonna build everything, get everything ready for you.

11:28Once you see this, everything is set up. Now all you have to do is open up another terminal just to make it easy. We'll take this command, come back over here, we'll go ahead and run that.

11:38You're gonna wanna see all four of these finish and successfully load. Now one of these is the network so it won't show in docker but if you open up your docker desktop, we've got my agent and we've got the three containers running right here.

11:52That's good. So now all we need to do is come back and we're gonna grab this URL that ngrok gave us. Come to our browser.

12:00Hit it. Boom. We're gonna create our admin account.

12:04This is only gonna happen one time. Of course, you're gonna pick a powerful password. You're gonna create it.

12:09Boom. Account created. Sign in with your new credentials.

12:13Sign in. You've got your beautiful interface.

12:17You can send your first message to your local LLM. And if you're into tools, the cool thing about this is that I'm using all of the latest technology.

12:27Notice how everything is streaming like a real AI chat if you were to use OpenAI or Claude. So everything is using the most up to date tools and SDKs that are on the market. And now you have a working PopeBot.

12:39Oh, by the way, I said I'd tell you how to set up Telegram if you'd like to use that still. All you have to do is come back to your directory here and you just type m p m run setup dash telegram and that's gonna walk you through the process for setting up your telegram agent and that'll work in conjunction with your web based agent.

12:59And one thing I did forget to mention is this is a fully functional chat interface. It fully supports attachments and PDF attachments if you wanna analyze images or analyze PDFs to extract the text. Alright.

13:10So now let me discuss a bit about the architecture and how this works. If you noticed, are using a platform called Docker. And at the heart of it, what Docker does is it allows you to run individual programs in a protected way inside of a protected environment that cannot access your actual computer where you're running everything.

13:29And that helps keep things not only secure, but it also just helps things from interrupting each other. And you can easily see this in the Docker desktop. We've got the agent running here with three separate containers.

13:41And these three separate containers are controlled by something called a Docker Compose file, which you can find inside GitHub, inside the templates here, right here Docker Compose. Feel free to just cut and paste this into Cloud and have it explain it in very simple terms.

13:56It's really worth your time. But let's talk about the three containers that are running inside of Docker. This one down here is the event handler.

14:04That is the actual PopeBot. That's running right here. This is the one that starts jobs and this is the one that's receiving the notifications from everything else so that it knows what's going on.

14:14This one here is nothing but a reverse proxy. It's a fancy word that might not mean much to you, but the reason why it's there is because if you are not running this on a local computer remember, when we do this locally, we're using ngrok and it gives us this protected SSL URL here that keeps everything secure while we're running it locally so that things can come in and we can access it.

14:34But if we were to deploy this to something like DigitalOcean, we need something that would generate that secure SSL certificate. Remember that HTTPS is what keeps things secure and encrypted as it travels across the Internet.

14:48So this is sitting here waiting for the people that wanna run this on something like DigitalOcean and need to create that SSL certificate. And again, the way I've set this up is that it will generate that SSL certificate for free.

14:58And then we also have this process here which is the runner. And this will start to highlight why we are using GitHub. There's quite a few reasons why GitHub is a great way to run all of this.

15:08But inside this runner here is where all of our jobs that we create in the event handler are actually being triggered and run. And this is super flexible as well and we're gonna get into it and you're gonna see the power. But if I jump back over to GitHub here and I click on these actions or again, we could just come here to the swarm.

15:24All of these jobs can really be run anywhere. It just so happens that when you run a local install, we can just run them all locally on your computer. Now it gets a little technical.

15:33We can actually run these on GitHub's own infrastructure as well. And they give you two thousand free hours of runtime. So you can take advantage of that or not.

15:42You can run it locally. Now the advantage of running it locally is that they're gonna start up faster. So when you use GitHub and you use their free stuff, it's gonna be a little bit slower which isn't necessarily a bad thing.

15:51But when they run locally, they're gonna pop up faster. They're gonna run faster. Okay?

15:55But what's cool about this setup here, so we have the event handler. We've got the reverse proxy.

16:01Again, remember that's for the SSL secure certificate. And then we've got the runner. The cool part about this is that if we want a simple setup to get up and running and this is a completely legit, you can just leave it this way.

16:12But if you expand, you can actually take all of these Docker containers and you can run them separately. So you can have all of these running on different servers and we could have multiple cloud servers available as runners.

16:25So this is where I talked about the scalability here. And so we could have hundreds of these agents running there all working together, all interacting and that's what's cool about using GitHub for this is that we're not necessarily using GitHub to run servers.

16:37We can but we're really just using the GitHub action workflows which make all of this just very easy to set up. So the scalability in the design is there. It's free or it's completely 100% scalable.

16:50GitHub also gives us a lot of other benefits as well and we touched on that. We can control and see everything that's happening and we can auto approve it if we want or we can approve every little thing. And I think it's gonna depend on your tolerance for the agent doing things on its own and just updating itself and modifying itself or those that wanna be a little bit more careful about what it does.

17:12So you have complete control over that. And you can always see everything that it's doing, everything that it's changing, and you can use all of this history. This is the agent actually doing its work.

17:20So you can look at its thought process and you can use these files to have it self improve. Right?

17:26So you can create a job in the heartbeat that will review everything that it's doing on a daily basis. It can give you a little recap of the previous day. This is what I did.

17:34Or you can say, hey, take a look at the logs and see what can be improved, see where the agent is struggling so that we can improve the system. So it keeps everything locked together. And so the code base, just like any other code that would normally be developed, is in here.

17:48Your configuration files. And you can actually modify them from here if you'd like. You don't have to even do it from the interface.

17:56You can come straight into here and you can modify the heartbeat. You can change whatever you wanna do here. You could come in and you can modify the cron itself.

18:04Now you don't have to. I'm just showing you the flexibility And not only that, if you created a really cool agent and you wanted to share it, all of the configuration files are here and you could share it as well. But most importantly, all coding projects and this is a coding project, this is a bot that's running, they all use git or something similar to it.

18:22And so we're going with the flow. We're not just setting up an agent that's able to modify itself with no transparency, with no way of knowing what's happening or tracking it.

18:32We have that. We can see every little thing that is being done and changed along the way. And we have the granularity in these settings to control in the variables here.

18:41Here's where we store the secrets and then in the variables here, here's where we can control whether things auto merge or not and what paths are allowed. So you can see here that we can auto merge as long as it's this path. So what I'm saying here is that if the job that just ran didn't modify any code and it only generated logs, we're gonna allow it to just automatically commit things back into the repository.

19:02But if I wanted to, if I just made this slash, then anything that the agent did could be checked in without review. And then of course we can set up a bunch of other settings as well.

19:11And I don't think I showed you how I would edit this if I did wanna do it from GitHub, but if you just click a file, you've got the pencil here. You just open this up, make the change and then you can commit the changes if you type something and it'll allow you to commit it. You just click that and then you could just commit it and it's gonna redeploy and it's automatically gonna get pushed back down here.

19:29You don't have to do it then. Now in terms of the roadmap, one of the main things I'm gonna be doing is just providing a lot more examples, showing you how the bot can self learn and create its own skills.

19:39I've been really focused on the technology and that core base that makes all of this possible. And I'd also really like to create an environment where we can all share all the different things that we build and benefit from each other as we build out our own agents. I'm also gonna be adding in a bunch of other chat platforms.

19:54We've got the new web interface and we've got Telegram, but we can add Slack and Discord as well. I do also plan to make some videos where we create a very powerful local computer using GPUs to run more powerful models.

20:08I'm running this on my Mac Studio right now. It works pretty well with Olama, but with a more powerful setup, we could run a premier model and run this twenty four seven, like have it perform like ChatGPT five or Claude's Opus model. And by the way, if you need support with your PopeBot, just go ahead and click that link right there.

20:23If you're experiencing any bugs, just open up the menu and report those here. And if you wanna be part of a community that's working on these types of problems, make sure to jump into the AI architects. I'm rebuilding this community from scratch.

20:35We're building out a new course system here. This is gonna be rolled out soon. This community is gonna cover everything that you need to build a modern AI business.

20:44The business side, the no code side, the vibe coding side, running agents twenty four seven side, and even how to build out these modern chat interfaces which is really where things are going. I mean, just take a look at how all the AI companies build their interfaces. It's always a chat.

20:58More on that later. I hope you enjoyed this video, and I'll see you on the next one.

The Hook

The bait, then the rug-pull.

Stephen G. Pope opens on a binary-rain animation and drops the villain in the first breath: AI gurus charging $100 a day in API fees and $500 Mac Minis. His counter-offer is both the title and the entire argument.

Frameworks