Transcription
You know, a few weeks ago I talked about open brain, which is a simple idea. You have a SQL database and you connect it via an MCP server to your AI and now your AI has a memory. And it's cheap because it's not disintermediated. It's not built on top of another company. It's just a clear, clean, free superbased database and that's it. So far so good. So many of you built it. That's great.
But what I want to talk about now goes beyond that. So if open brain gave you a memory, I want to talk about how you can use common natively available tools inside AI to give your memory a heartbeat, a proactive rhythm, and to give it tools so that you can have it do useful work. This is really about putting an agent together because an agent is like memory plus tools plus the ability to be proactive. And so that's what we're going to cover here. And yes, I'm going to talk about examples. I always do. I'm going to include examples in my substack. I always do. That's all great.
But the key thing that's different is OpenBrain has become a community project. Thousands of you have built it. And so I am opening this up to the community. You guys will have a space to communicate and to share your own recipes for how you are using OpenBrain to tackle different kinds of projects so we can all learn from one another. And I think that's really cool because you guys are going to come up with some incredible use cases. And I wanted to find a place for that to be shared, for that to be visible for everyone. That's something that has literally been thousands of messages in my Substack community over the last few weeks. And we need a place to share it and to share these use cases.
So, as much as this video is about how do you put together uh proactive action with memory, with tools, and that's super important. We're going to talk about a feature that Claude launched that most of us didn't pay attention to. Cool stuff. I want you to know that there is a way for you to communicate and contribute your favorite use case for an agent to our growing recipe rolodex for agents. It's going to be super cool.
And if you're like, "Wait, Nate, uh, tools, memory, uh, being proactive, this sounds like OpenClaw." Yeah, it should sound like OpenClaw. One of the really interesting things about the whole OpenClaw phenomenon is that what people were interested in was so simple. It was a framework that let an agent take actions with particular tools on a particular schedule against a particular database. And it turns out if you combine OpenBrain and tool sets and you combine proactive action, you get a lot of the capabilities of OpenClaw without having to download that repo and install OpenClaw specifically. And so we're going to get into that more. There's going to be a whole piece of the Substack guide about it. But I also want you guys to have the space to contribute your own open claw-l like recipes that are using those simple primitives using memory using tools and using the ability of the AI to be proactive.
So now let's jump in. So last week Anthropic shipped a little noticed feature called loop. Now you might be like what is loop? Why do I care? Loop is just a way for claude code to run a job without you being at the computer. It lets your agent be proactive. And what people didn't notice is that this is the last piece you need to recreate Open Claw. And I think Anthropic did it on purpose.
So, let's open up the box of Legos. Let's look at what's on the table and let's go through each component. And I will show you the three key components that make it possible to have an agent that does proactive work like OpenClaw without necessarily getting into the security issues that go with OpenClaw. So, we're going to be super simple here. We're going to keep it really high level. We're going to talk about use cases and then if you want more details, you know, you can always go to the Substack where I have a complete guide for how to put this system together.
So, there are three things an agent needs before it stops being a chatbot and starts being something you can actually send work off to. It needs memory, which is the ability to read and write to something persistent. So, it remembers what happened yesterday, last week, 3 weeks ago. Without memory, every single interaction starts from zero. and the agent is perpetually a new hire on their very first day.
Block two is proactivity. That is what anthropic ship is. It's the ability to act without being specifically prompted that time. So the agent will wake up, it will check on things, it will do a job and go back to sleep on its own schedule. Without proactivity, the agent only moves when you push it. You are the metronome. And every minute you spend being the metronome is a minute the agent could spend doing work. And frankly, who has the time to remember to bug their agents?
And then the third big piece is tools. It's the ability to reach out and touch systems, to pull data, to call APIs, to generate artifacts, to write to databases, to trigger workflows. If you don't have tools, the agent can think, but it doesn't have hands and feet. It's a brain in a jar.
So a few weeks ago I introduced OpenBrain, a personal knowledge database that you own connected to your AI tools through MCP servers. Thousands of people in the community responded and they built their own versions. Some of you are using it for work. Some of you are using it for personal. The beauty of this system is that you can decide how you use it and it's your memory and it's your database and you get to pick. That addresses the memory component. Now, you can make it fancier, you can make it less fancy, but fundamentally if you have a database through an MCP server, the agent can call that database and it can see what you've put into it. It doesn't cost much to run. I think it cost 10 to 30 cents a month to run. There's no platform lock in the way I recommended it and there's no amnesia.
But one of the things that we were missing in this whole story was the heartbeat, a way for the agent to wake up on its own, to check on things, to act on what it finds, and to go back to sleep without you being the one to poke it every time. Slash loop is that heartbeat. It solves proactivity for agents. And it doesn't just solve it for people who built my open brain version because my open brain version, it's just a SQL database, right? Like it's a SQL database tied to an MCP server. It's not super special on its own. It's the components that come together that make the agent special. And so what I want you to recognize is that what we are seeing out there more and more is all the components you need to put together a personal agent that does real meaningful proactive work for you. And that's what this video is all about. How do we name those Lego bricks like memory and productivity and tools? How do we put them together in ways that are useful for us to do real work? And what does that look like in practice?
Now, if you've already built OpenBrain and if you've already connected it to tools, you're so close, right? You can just add / loop and now you have a proactive agent. And that is the entire reason I recommended setting up a SQL database to act as a memory store and sticking it behind an MCP server. It is so simple. It works with you when new launches happen. And so, a new launch happened that I didn't plan on called / loop. And it conveniently, strategically reinforces the value we've already built. That is why you think about what you choose to design before you design and implement it. We want to build our agentic systems whether they're personal or professional so that they are in line with where the ecosystem is going. And that's what we're doing here.
You might wonder what is a real example, Nate? Why do we care about memory and tools and productivity? What is it about those three that is magic with an agent? Start with a really simple case. You're trying to get your energy levels under control and you ask an agent to check in with you every morning with SL loop and no memory system. Let's say you're not hooked up to open brain. You're not hooked up to any other memory system. The agent just asks how you slept, what you ate, and how you feel. If you say, "I'm tired today and I skipped breakfast and I feel groggy." It'll say, "Drink water, take a walk, eat something." And tomorrow, if it asks again and you say, "Tired, had coffee but no food, headache by 2 p.m., it'll give you more advice. eat a real meal." This is already a big step, right? It's nice that the agent is proactive and Claude gives you this without any kind of memory system at all.
But think about what happens when the system gets memory because right now in this example, the agent has no memory. It doesn't know that you've done this two or three days in a row. It doesn't realize you've been tired nine of the last 12 mornings. What happens if the agent recognizes the pattern? That is what memory gives the agent. And that is why you have to think about how to stack these Legos together to get real agentic workflows and long-term value.
So let's say the agent does a morning check-in, but now it has a SQL database. It could be open brain. It could be whatever other implementation you want. It writes what you report, energy levels, sleep quality, and meals back to the database. The next morning, before it gives you advice, it reads what it wrote yesterday and the day before and the week before that. Hey, you've reported low energy nine of the last 12 mornings. the three good mornings were the, you know, the 1st of March, the 4th, and the 7th. If we look at what those days had in common, it then queries the brain and finds its own notes. All three followed evenings where you ate before 8:00 p.m., right? Your energy problems. And and then look at what the agent can do. Hey, your energy problems seem to correlate strongly with late eating and late sleep, not with caffeine. So, the caffeine experiment that you ran a couple of weeks ago actually didn't help because the underlying pattern is your meal timing. Look what happened. The agent didn't just respond to your morning complaint. It recognized a pattern across weeks, retrieved its own prior observations, identified the real variable, and dismissed the one that didn't work, and then gave you a specific action tied to evidence that it put together itself. That is the difference between a parrot that repeats a phrase, which is what you get with loop, and a detective that builds a case, which is what you get when you combine memory and proactivity. One recites, the other accumulates evidence and acts on a pattern. You have no pattern recognition without memory.
This same principle, by the way, if you think this is only a personal example, it obviously scales to business, too. Take customer success. An agent runs weekly health checks across your accounts, usage metrics, support tickets, engagement data. Without memory, it tells you, hey, usage is down 15% and moves on for this particular client. With memory, it reads what it wrote last week, sees that usage was down 15% prior week and is now down 28% total, and it finds a similar example with a similar trajectory from 6 months ago, also in the memory database. And then it comes out and says, "Hey, this is a pattern we've seen before. It looks like that account really went down the drain after 3 weeks. We want to avoid that. Let's go flag this for executive outreach this week." Again, the agent didn't just parrot a metric. It pattern matched against its own history of account failures and recommended action with a deadline. Proactivity got it going. Memory made it smart. The two together are needed.
So, now we have an agent that can wake up on its own and learn from what it finds. But we're not done yet. I mentioned tools earlier in the video. I want to dig into what tools bring you because so far the agent can only talk to you in this example. The third primitive tools really changes this. And I'm using these specific examples because I think that so often when I talk about agents, people think of them as little guys. And that's great, but you have to understand what those little guys do and what what components come together to make them able to do useful work. Tools are one of those big pieces. They really do give the agent hands.
In software terms, a tool is very simple. It can enable an agent to pull data from systems to build stuff like generate an artifact, write data. It can trigger a whole workflow. It can reach to another service where other work lives. All of those things are tools, but I think that that's sometimes too abstract. So, let me give you a specific example. Let's say you go to a networking happy hour every Friday evening. Your agent knows this because it's in the brain because you've been doing a good job logging it, which I talked about in a prior video. On Friday afternoon, the /loop command that Anthropic launched fires. The agent queries OpenBrain for every person you've interacted with in the past couple of weeks. It looks for meetings, for emails, for Slack threads. It pulls context on who they are, what you talked about, what's still outstanding. Then it calls a tool. Maybe it's Remotion. It's a video generation tool that you can connect via MCP. And yes, I have a guide for this. The agent passes all those names, those conversation summaries, all of that context to Remotion and generates a personalized briefing video for you with faces, talking points, follow-ups you owe that you can watch on the way to the event.
>> Yeah. So, he's not making that up. Claude code can call Remotion through MCP, hand it structured data from your open brain, names, context, talking points, and Remotion renders an actual video. The agent writes the script, the tool renders the frames. The loop means it happens on a schedule without you asking. In fact, this video, the one you're watching right now, Claude built it. not a text dump, a produced visual briefing built from your own data. The agent passes on the names, the conversation summaries, the context to Remotion and generates a personalized, detailed briefing video for you that you can watch on the way to the event with talking points, follow-ups, people you should focus on. It's not just a text dump. You actually get a a visual briefing built from your own data assembled by the agent, rendered by a tool, delivered on a schedule. That is tools plus memory plus proactivity working together to do useful work.
Or maybe you don't need a video. Maybe the agent just queries your calendar and it cross references it with your memory system and it sends you a Slack message. Hey, you're seeing Sarah tonight. Last time you talked, she mentioned her team was evaluating a new data platform. You said you'd send her the write up, but you didn't because I've been looking and you didn't. Here's that link. you might want to send it before you walk in the door. This sounds like magic, but these kinds of magical moments are actually built on really simple building blocks. And the thing that makes sloop a big deal is it is one of those core building blocks. And you now no longer have to go and get a special extra addition to your claude code to do that.
Because I'll be honest with you, there were people who were doing stuff like this before. In fact, the whole open phenomenon can be simplified as saying Peter Steinberger put together an LLM with memory plus tools and made sure you could message it from a messaging platform. It's actually not that complicated. So when you see a launch like this from Anthropic, you should be looking at it in the context of the agent openclaw movement because that has reminded the world that we are hungry for agents. We want agents that can do real work. You can look at the 200 some thousand GitHub stars on OpenClaw. It's the fastest growing piece of software in history. In fact, Jensen Huang, the CEO of Invidia, has called it the most consequential software launch in history. People are so hungry for agents. And the beautiful thing is you don't have to use OpenClaw to get OpenClaw like work done to have an agent like OpenClaw. And that's what you get if you put together something like a little SQL database with an MCP server which I call open brain and a/loop command from Anthropic and a little bit of tool use. It's really not super complicated and I think it's really important because we can do things that we would never be able to do otherwise.
I can't tell you. I I know I used the happy hour example, but that's partly because whenever I've been networking, it's always been tough for me to think, what do I strategically want to accomplish here? What matters? Who should I talk to? Well, these kinds of small personal challenges add up. And you may not realize how many different personal and professional gaps you face that an agent could close. And that's why I care about being specific. So, I'm going to be more specific. I'm going to keep talking about examples here.
Let's say you do job applications. You do them every Thursday afternoon. Sloop fires at noon on Thursday. The agent reads your open brain for what happened since last Thursday. It reads it for projects you shipped, for conversations that went well, for metrics that moved. It pulls your resume from a connected drive. It writes the draft to a doc and pings you, hey, I updated the cover letter already. I added the deployment metric from Tuesday and the client testimonial from the Slack thread on Wednesday. please review for your application session. In other words, you have a proactive buddy on the job application search. And yes, I know updating your cover letter might not seem glamorous, but now it's the agent's job. And it can also help you in other ways. You can have an agent with toolled access go out and scrape for job postings. You can have an agent with tool access go out and look at how to adjust your resume to job postings proactively so you can review it without having to touch it yourself. There are all kinds of things that you can solve proactively. When you think of the world as a set of problems that you can solve with something that has memory and something that has tools and something that has a schedule, it is amazing how much of the world that covers from a task perspective.
Let's say you're managing a content calendar. The agent is going to run every morning. It's going to check what's scheduled to publish this week. It's going to read the open brain for any recent news or conversations that might be relevant to upcoming posts. It's going to search the web for breaking developments in your topic areas. that's going to flag conflicts or opportunities. Hey, your Thursday post on AI coding tools references cursor pricing. They announced a new tier yesterday. You might want to update the comparison table before it goes live. Each of these follows the same agent cycle, right? The agent proactively awakens with /loop. It proactively reads a memory system. It proactively calls tools and it takes an action and then it writes that action result back into the memory system. So you set the rhythm once and then you don't have to think about it again for anything that's scheduled. That's not really a chatbot. That's not even an assistant you have to remember to ask. It means that it's a proactive agent that comes to you. Honestly, I have worked with people who don't do this, right? I have worked with people that you have to chase for every single deliverable. Do you know how tiring that is? That is the difference that proactivity makes. And that is why the sloop command is such a big deal.
But there's one thing more that I want to call out here. You might be thinking of sloop as this is a command that helps me on the next job. And that's true. But the larger principle here is that the value of setting up a loop like I'm describing a proactive action where you're reading and writing to a database and improving memory over time. It's the accumulation across cycles that matters here. Right? One of the most popular uses of AI agents in the last few months is the overnight coding loop. If you give your agent a goal, like improving test coverage or refactoring a module or migrating a dependency or honestly just doing research for you, so you can look at job postings in the morning or you can look at competitive news in the morning or you can look at AI news in the morning and the agent will just work on that and it will work through the night and it will work while you're not at the desk. That entire technique was happening before Sloop launched and it blew up because it works. Developers went from non-working software to software that mostly worked overnight or entirely worked overnight. I saw multiple examples because they were able to get the agent to do a loop over and over and over and over again until it got a job completely done. But until now, implementations like that required some degree of scaffolding or structure around your agent implementation. You had to have external tools that managed the loop that managed restarting the agent and going again. And you had to have markdown files to carry context between iterations. And you had to have completion conditions, we call them eval, bolted on with duct tape. And the reason for all of this was pretty simple. The agent had no native way to run on a schedule and no native way to remember what it did. Slash loop solves the first problem. It solves how the agent remembers to do something on a schedule. If you have a memory system, you can address that second piece as well. Together, that turns a hack into architecture.
Here's the principle that ties all of this together. The value of a loop isn't in any single cycle. It's in the accumulation across cycles. Let me give you an example. Over the past few months, developers have been really, really excited about putting together agent scaffolding that lets an agent do a task over and over again until it passes a certain test. And this has allowed developers to go to sleep and wake up to working software. And the three or four building blocks in there that really matter are that the agent is proactive, that it can repeat tasks, that it knows what it did last time, and that it is able to pass a series of tests to make sure the software actually runs before it says it's really, really done. Now, that has required developer scaffolding. You have to get a framework to make that work or you have to roll your own framework. And developers are fairly technical and they have no trouble doing that. For the rest of us, that can be challenging. And so one of the things I notice is that these developer patterns start to move into non-developer spaces. And that's a lot of what loop does for us because it means that we can be proactive across time and we can get accumulated work done if we're talking with a memory system like open brain or something else. And that matters a ton because you can get a lot more work done if you have accumulating proactivity cycles which is really what loop gives you.
Let's start with a specific example to see how these cycles accumulate net value over time. Let's say your agent runs every morning at 6:00 a.m., but this time it's running against a sales pipeline. Every cycle it reads the memory system. And by the way, OpenBrain does scale into small corporate contexts. But I will be honest with you, the point here is not to use a particular thing that I'm pedalling. That's not the point. It's just a SQL database behind an MCP server. Let's say this. Your agent runs every morning at 6:00 a.m. against your sales pipeline. And if you're wondering, can I use this in business? Can I have an agent that queries memory? Could could my open brain work for this? There are people in the community that are doing exactly this. So, yes, it does. Each cycle, it reads the memory system and it discovers something like this. Yesterday, I reviewed 34 inbound leads. Let's say eight of them met my ICP ideal customer profile criteria. Of those, three already had active conversations going and I flagged them for follow-up. The agent is doing all this proactively, right? Two were duplicates of leads that we lost in Q2. I tagged those as win back. The remaining three are net new and qualified. I drafted first touch emails using the messaging that got the highest reply rate last month. And so in this case, the agent is proactively looking at the database to look at previous touches from the sales team and it's using tools. And this is why it's so important to understand structures of agents because yes, you can do this with an open brain implementation, but you can do the exact same thing if it's talking to Salesforce and Salesforce is your CRM of choice. The the principle is the same. It's just Salesforce is acting as the memory system instead of something you built yourself. And the beauty of these proactive cycles is that they keep compounding. the agent can pick up SMB emails tomorrow and it knows it already drafted the emails to your ICP into enterprise and so it's going to go back and look at SMB leads and recognize the work it did and move on to the next task. And that combination of proactivity and memory allows it to do the kind of proactive pattern matching and take action with tools that you could never do without those three Lego bricks together. Without memory, without proactivity, without tools. Ultimately, the ability to build on these compound loops is what enables agents to go from just doing work to building momentum. And that's why it's so important to put these three primitives together. Proactivity keeps the loop turning. Memory keeps each turn informed by the previous turn. And tools let each turn actually change things in your work environment. If you remove any one of the three, it's not really the same agent anymore.
I want to give you an example from just the past week or so that I think was a really big deal that most people didn't pay attention to. Andre Karpathy open- sourced a project called Auto Research. It gives an AI agent a training setup for a small language model, a single GPU and a clear success metric and then it lets it run experiments independently overnight. The agent modifies the code. It trains for exactly 5 minutes. It checks if a metric improved. It keeps or discards the results. and then it loops. You can run about a 100 experiments overnight with zero human intervention. The key architectural decision is the same one we've been talking about in this video. It's a persistent log of what the agent tried, what worked, and what didn't. Without that log, the agent would be running random experiments, no better than a brute force search. With it, every experiment is informed by the full history of previous experiments. The search becomes intelligent and that enables the agent to converge on a better pattern. Shopify CEO Toby Luki is one of the most technical CEOs out there. He picked up this GitHub repo from Andre Carpathy. It's out there. Anybody can grab it. You could grab it. And he made an agent optimized smaller model that outperformed a larger model that had been handtuned by a human. Not because the agent was smarter in any given cycle, but because it ran a 100 cycles and remembered them. This is really cool if you're into training LLMs to do stuff. And that's a great use case on its own, but the principal scale, even if you look at the idea of training an LLM and you're like, that is not for me. Let's say you're tracking a competitor, you're researching a market, you're monitoring regulatory changes in your industry, you're following a technical domain like AI that moves really fast. Without memory, an agent checking on these things every morning gives you a snapshot. With memory, it works. And with memory plus tools, you can do really cool stuff.
Now, if you're really thinking, Nate, you're just describing OpenClaw, I am, but without the chaos. So, when I talked about OpenClaw, I had to talk about the fact that it was a security nightmare. That people using OpenClaw were opening their networks to the wider internet, that they were giving their OpenClaw instance access to data they shouldn't, they were downloading extensions for their OpenClaw that had severe security vulnerabilities. And that is all really true. Security researchers have called OpenClaw a nightmare. And none of it has slowed down the desire of people to have agents. What's interesting is you can get so many of the same capabilities just by stacking these primitives together. And so you don't have to specifically download the open claw instance to get an agent that has tools and memory and proactivity. Now sloop gives you that capability. It gives you the capability to have an autonomous agent plus a persistent memory with a little database like open brain or something else plus tools that you can act on. And so in this world, the heartbeat for this agent, the ability to do something on a rhythm comes directly from anthropic. It's a native command. It's not a bash script. It's not something you download to run. The memory lives in a database that you can control. It's accessed through a standard protocol, not through an orchestration layer with prompt injection vulnerabilities. So that allows you to get a lot of open claw- like behavior without the open claw software layer because the scheduling belongs directly to enthropic. You can have your own memory layer and you don't have to touch the open claw protocol to get open claw like results.
Now people will tell me but there's a lot more I can do with openclaw because it's a fullyfledged out framework. Undoubtedly true and I'll be direct about the gaps because the point of this video has been to tell you why small changes like loop are actually really big deals and you should pay attention to them. So yes, there are gaps. For example, right now there's no built-in done signal with /loop. It just runs until it expires or you stop it. For goal directed work, you will need to tell the agent to check the brain for a completion state and stop when it finds one. Or you'll need to set up and run evals. And yes, I have a little guide as a part of this video on Substack that helps you understand what an eval is without being scary. And so there are absolutely ways that you can do that. It's just going to take a little bit of extra work. And other limitations are real as well. Everything is scoped to the active session you're in. If you close your laptop, this whole proactive schedule doesn't work. Anthropic offers desktop level scheduling, but really always on operations across restarts. That's not an anthropic native capability and you'd have to build something for that differently. I will also admit that the skill ceiling is still real because slashloop is in cloud code and whether we like it or not, even if some people who are non-technical like to use claude code, it's still daunting.
But one of the things I want you to recognize as you think about whether or not you want to try something maybe scary like the terminal is that it's a way for you to time travel. Yes, the tools I'm talking about will eventually come through and be available in more user interface friendly environments like co-work like Claude the chatbot like chat GPT it's going to happen but this is all coming to developers first because developers in code are deliberate strategic beach heads for all of the hyperscalers right now and I have separate videos on why that is and that means that the developers get these agent capabilities before anybody else. And so if you're willing to go to the terminal, you get free time travel. You get to go months and months ahead of everybody else just by being willing to use a different window on your computer. If I told you you could time travel by using a different window on your computer, 99 out of 100 people would say, "I don't believe you." And if they did believe me, they would immediately try it. Well, that's what the terminal is right now. If you're willing to jump in and just dip a toe in, you can time travel.
And you might wonder, why is Nate talking about open brain? Is he trying to shill something? I'm actually just trying to build on what the community has built. A bunch of you have built this thing already, so let's just use it. If you have a memory system and it's doing a job for you, why not take something like /loop and give it a proactive heartbeat? That's super convenient. You don't have to build the thing again. And if you're like, what is open brain and want to build it, there's a guide out there for that. No worries. The point is not that you build my open brain, whatever that is. that that was never a thing. It's just a SQL database on an MCP server. The the point is that you give your agent a memory and you give it a tool set that it can act against. And then you give it a proactive behavior loop, which is what sloop is. And so it can go and do things. As I've been saying, it's not perfect. It can't do absolutely everything open claw can do, but it can do a lot. And depending on what you put in that memory, it will not have the same security issues.
Now, as always, this depends on common sense, right? If you put hyperpersonal information into your database and you give your agent a tool like open access to the internet and you don't constrain it properly, you could get in trouble. That's true. But if you build your database properly, if you decide what the agent has access to and what it doesn't, and if you give them and if you give your agent proper tools, you're going to be in a place where you can do actual useful work with the agent that accumulates in value over time because of that /loop command. And that's going to be super powerful. And you don't have to jump into the open claw environment if you don't feel like you're ready. And Peter Steinberger himself who built OpenClaw has been very clear that he does not see Open Claw as being something that you should use if you are not a very technically sophisticated user because of the risks associated with it. I think he's right. Part of why he went to OpenAI is because he wants to build something eventually that is like Open Claw but not as technically challenging but still secure. While he waits and builds that, you don't have to wait. you can use these basic tools and you can set up your agent and get useful work done.
Now, I hope this video has given you a sense of two things. First, why it's important to strategically think about these small releases that come out like/loop. And second, why it's important to think about your agent in terms of the Lego bricks that make agents tick because that allows you to quickly grab onto a piece of news and say, "Is this something that helps my agent workflows work better?" Or maybe it doesn't matter. Like, is it a new tool for something I care about? Maybe you care about videos and my Remotion example really works for you. Maybe you care about email and giving your agent an MCP server into your email account really matters. Regardless, understanding your goals and understanding how to read the news in terms of these basic components that make an agent tick is going to really help you feel like you can sort through things, make sense of them, and put something together that adds value. Cheers.