Author: Michael Gu

Is OpenClaw Overhyped? My Honest Take After 2 Months

After using OpenClaw for over two months, I keep getting the same question: is it overhyped? A post from Miles Stoer caught my eye this morning — he argued that most people shouldn’t use OpenClaw and that he’s moved his workflows to Claude Code instead. So I wanted to give you my honest, unfiltered take on where OpenClaw actually shines and where it falls short.

The Short Answer: It’s Not Overhyped, But It’s Not For Everything

Let me be real — I don’t use OpenClaw to run my life. I don’t let it read my emails, manage my calendar, or handle scheduling. There’s still roughly a 2-5% chance it’ll mess things up, like getting dates wrong or hallucinating details. That’s just the nature of AI agents right now, and it’s a point that TechCrunch recently echoed in their piece questioning whether OpenClaw lives up to the buzz. Some AI experts have pointed to its complex setup requirements and high computational demands as reasons for skepticism.

Instead, I let OpenClaw handle tasks that are time-intensive, repetitive, and where mistakes aren’t catastrophic. That’s the sweet spot.

Where OpenClaw Actually Excels: Daily Briefings and Cron Tasks

The thing OpenClaw does better than almost anything else is recurring daily tasks. I have it generate a daily briefing presentation for me every morning — it just runs automatically via cron jobs, no prompting needed. I wake up to a full rundown of what’s happening in the crypto and AI space, complete with actual quotes, linked tweets, and sourced data.

This didn’t happen overnight though. Over time, I refined the instructions to make sure it wasn’t gaslighting me. Early on, it would flat-out lie about video view counts or make up restaurant locations. My fix? I told it to always include source links, and I even set up a sub-agent to fact-check everything before the briefing gets delivered. These tweaks drastically reduced the slop and made the output genuinely useful.

OpenClaw’s architecture is actually well-suited for this kind of work. Since it gained popularity in late January 2026 thanks to its open-source nature and the viral Moltbook project, the community has built out robust cron scheduling and monitoring capabilities. Tasks that need to happen daily, that benefit from memory across sessions, and that can be iteratively improved — that’s where OpenClaw is in its element.

Content Ideas and Creative Bouncing

I also have a second bot that scans trending videos and gives me daily intel on content opportunities. When I talk back to it and say “here’s what I’m interested in, suggest some video ideas,” it’s genuinely useful as a brainstorming partner.

The key insight here is that none of this is mission-critical. If the bot suggests a bad video idea, nothing breaks. I can accept or reject its suggestions freely. It’s low-risk, high-reward automation — and that’s the mindset you need when working with AI agents in 2026.

I’ve even had it scan through my old videos to add referral codes I’d missed, then save the process as a reusable skill for future use. Setting up skills in OpenClaw is honestly one of the most important things you can do to get real value out of it.

Where OpenClaw Falls Short: Don’t Trust It With Your Life

Here’s where I have to be honest about the limitations. We had an incident on our team where OpenClaw randomly messaged Ron’s girlfriend. Just out of nowhere. That’s the kind of thing that happens when you give an AI agent too much access without proper guardrails.

I don’t trust OpenClaw enough to let it into my Mac or manage my personal communications. And I think that’s exactly where the “overhyped” perception comes from — people install it on their local machine, give it broad access, and then get disappointed when it can’t flawlessly run their entire digital life. As CNBC reported, some experts have criticized OpenClaw’s complex installation and the gap between expectations and reality.

The way I see it, OpenClaw is like a $500-800 virtual assistant from a developing country. They can handle rough tasks, they have some coding skills (which is a huge bonus), but they make mistakes 2-5% of the time. You wouldn’t trust them with mission-critical work — that’s what your executive assistant is for.

OpenClaw vs Claude Code: Different Tools for Different Jobs

Miles’ original post suggested using Claude Code instead, and honestly, I use both. Claude Code is fantastic for programming tasks — it excels at parallel task execution, deploying sub-agents, and agent orchestration. As DataCamp’s comparison puts it, if your main use case is programming, Claude Code is the way to go. If you need a general-purpose assistant, OpenClaw is the better route. One comparison I saw described it perfectly: it’s like comparing a Swiss Army knife to a surgical scalpel.

I actually plug my OpenClaw into Claude as its language model, but Claude Code is even better at leveraging Claude’s capabilities for building systems. If you want to build something fun — like the mini-games I’ve been making — Claude Code will get you there faster. But it takes 2-3 weeks to really learn, and it’s a bigger scope project.

My Setup Recommendation

If you’re going to use OpenClaw, here’s my advice: run it on its own virtual private server, not your local Mac. The open ports let you directly access files, share presentations with friends, and browse dashboards from anywhere. Letting it build dashboards and visual presentations with coding capabilities will dramatically improve your experience.

And most importantly — understand what level of “employee” your AI agent is. Don’t try to build your entire life around it. Delegate the right tasks: repetitive daily work, content research, data monitoring, and creative brainstorming. Keep the mission-critical stuff in your own hands, at least for now.

I genuinely believe that in about six months, we’ll get to the point where these agents can function as true executive assistants. But we’re not there yet, and pretending otherwise is what leads to the “overhyped” label. Use OpenClaw for what it’s good at, and you won’t be disappointed.

February 26, 2026
OpenClaw Skills Setup Guide: Build Custom AI Agent Automations

If you’ve already got OpenClaw up and running, the single most important thing you should set up next is Skills. I genuinely believe this is what separates a basic AI assistant from one that actually works for you — to your exact specifications, every single time. In this guide, I’ll walk you through what Skills are, why I build my own instead of downloading them, and how you can create custom Skills that transform your OpenClaw bot into a truly personalized AI agent.

What Are OpenClaw Skills and Why Do They Matter?

Skills are essentially instruction sets that tell your OpenClaw agent how to perform specific tasks — think of them like muscle memory for your bot. Without Skills, your agent starts fresh every session. It forgets your preferences, your formatting choices, your workflow quirks. With Skills, it wakes up knowing exactly what to do and how you like it done.

This matters more than most people realize. OpenClaw, like most AI agents, clears its context window between sessions. The best analogy I can think of is that your bot essentially “dies” every day and comes back trying to remember everything. Skills solve this problem by giving your agent persistent knowledge — it’s like your bot knowing jiu-jitsu without having to relearn it every morning.

The OpenClaw ecosystem now has over 3,200 community-built Skills available on ClawHub, the official skills registry. That’s a massive library covering everything from browser automation to financial tracking. But as I’ll explain, I think building your own is the way to go.

Why I Build My Own Skills Instead of Downloading Them

I’ll be honest — I don’t really go on ClawHub to download skills. There are two reasons for this. First, everyone has different preferences and workflows. Someone else’s presentation skill might format things completely differently from how I want them. Second, and this is important, there have been some security concerns with community-uploaded skills in the past. ClawHub now has virus scanning, but when you’re giving an AI agent instructions that run on your machine, I’d rather be safe than sorry.

Instead, I design my own Skills by simply talking to my bot. I didn’t write a single line of the skill file myself — I just told my agent what my preferences were, how I wanted things structured, and said “save this as a skill.” The bot wrote up the entire SKILL.md document for me. That’s the beauty of it: you don’t need to be technical to create powerful, custom Skills.

My Daily Presentation Skill: A Real Example

Let me show you a concrete example. I have a presentation skill that automatically produces daily briefings about what’s happening in both crypto and AI. Every morning at exactly 8:00 AM, a cron job triggers this skill, and by the time I sit down with my coffee, there’s a fresh research presentation waiting for me.

The skill knows the structure I want, the research depth I expect, where to save the files, and even which directory to use. It actually calls upon another skill — a deep research skill — to gather the information before assembling the presentation. Skills can build on top of each other like that, which is where things get really powerful.

The cron job scheduling is key here. OpenClaw lets you set up scheduled tasks so your agent runs specific Skills at set times without any manual input. I have mine set to run first thing in the morning so all the news is fresh. I can then decide what to cover on my YouTube channel or use for other content. It’s hands-off automation that actually delivers quality output because the skill specifications are dialed in.

How to Create and Refine Your Own Skills

Creating a skill is surprisingly simple. Here’s my approach:

Start by talking to your bot. Tell it what you want done. Be specific about your preferences — the format, the tone, the sources, the output location. Don’t worry about documenting it perfectly; just have a natural conversation about what you need.

Ask it to save the skill. Once you’re happy with how the bot handles your task, say something like “save this as a skill” or “create a skill for this workflow.” Your agent will generate a structured SKILL.md file with all the specifications.

Refine over time. This is the part most people skip. After using a skill for a while, you’ll notice things you want to change. Just tell your bot: “Update your presentation skill — I prefer light theme now” or “Your research wasn’t deep enough, make sure you check at least five sources next time and update that in your skill.” The bot handles the file updates automatically.

The key phrases to remember are “update my skill” and “save this as a skill.” These trigger the agent to modify or create the SKILL.md files that persist between sessions.

ClawHub: Good for Inspiration, Use With Caution

While I prefer building my own, I do think ClawHub is worth browsing for inspiration. Seeing how other people structure their skills can give you ideas for your own workflows. The platform uses vector search to help you find relevant skills quickly, and there are some genuinely creative community contributions — from self-improving agents to advanced browser automation.

That said, I’d recommend using ClawHub as a reference rather than blindly downloading and installing skills. Read through what a skill does, understand the approach, and then build your own version tailored to your needs. As a human, you want to filter out the good from the bad, especially when it comes to code that runs autonomously on your machine.

Final Thoughts

Skills are what make OpenClaw go from a cool toy to an indispensable daily tool. The combination of custom specifications, cron job scheduling, and the ability to chain skills together means you can build genuinely sophisticated automation workflows — all by just talking to your bot.

If you’re just getting started, pick one repetitive task you do regularly and turn it into a skill. Refine it over a few days. Once you see how much time it saves, you’ll want to skill-ify everything. And if you have suggestions for what we should cover next, drop a comment — my bot actually has a skill that reads through comments and suggests video topics to me. So yes, your feedback literally gets processed and repeated back to me multiple times.

Make sure to subscribe to @BoxminingAI for more guides, and join our Discord community to share your own skill setups with the growing community.

February 26, 2026
How to Add ANY API to Your OpenClaw Agent (Step-by-Step)

Your OpenClaw agent is smart — really smart. But without the right tools, it’s like a chef without a kitchen. In this video, Ron and I walk through one of the most important skills you can teach your agent: how to connect it to external APIs. We use a YouTube transcript API as our example, but the process applies to virtually any API out there. Let me break it down.

Why Your Agent Needs APIs

Out of the box, your OpenClaw agent can browse the web and fetch pages. That sounds like it should be enough, right? Not quite. The reality is that many websites actively block bot access. Twitter (X) is notorious for this — paste a tweet link and your agent will just stare at a wall. CoinGecko, one of the most popular crypto data sources, also restricts automated access because that data is valuable and they want you to pay for it.

This is where APIs come in. An API (Application Programming Interface) is essentially a structured doorway that lets your bot request specific data directly, bypassing all the anti-bot protections on the front end. In 2026, APIs have become the backbone of AI agent ecosystems — industry research shows that AI agents rely on APIs to read data and take actions in real systems, from SaaS platforms to databases to internal services. Without them, your agent is flying blind.

Finding the Right API: YouTube Transcripts as an Example

For our demo, we wanted our agents to grab YouTube video transcripts automatically — super useful for generating timestamps, summaries, and descriptions. We used a service called youtube-transcript.io, which turns any YouTube video into a clean text transcript via a simple API call.

The signup process is straightforward: create a free account, and they hand you an API token right on the dashboard. Think of this token as a password specifically for your bot. I know the word “API” can sound intimidating, but honestly, it’s just a key that unlocks a door. Your bot does all the hard work behind it.

This same pattern works for hundreds of other services. Need crypto prices? There’s an API for that. Want social media data? There’s an API. Weather, news, translation — you name it. The setup process is essentially the same every time.

The Setup Process: Three Simple Steps

Here’s the workflow I use every time I add a new API to my agent. It works whether you’re connecting to a transcript service, a crypto data feed, or anything else.

Step 1: Paste the API documentation. Most API services have a documentation page that explains how to make requests. Copy that documentation and paste it to your agent. Tell it something like: “Read up on this API documentation and make a skill to fetch transcripts.” The beauty here is that API docs are written for programmers — and your bot is a programmer. These AI models pass top-tier coding exams, so they can parse technical documentation far better than most humans.

Step 2: Give it the API key and save it. Hand your agent the API token and tell it to save the key to the .env file in your OpenClaw directory. This is a hidden environment file where sensitive credentials are stored. The models are trained not to reveal what’s in this file, so it’s a safe place for your keys. Just remember — never share your API tokens publicly.

Step 3: Test it. Ask your agent to actually use the API. In our case, we said “get the transcript for this video” and confirmed it could pull the data successfully. This verification step is crucial — it proves the integration actually works end to end.

Save It as a Skill

Once your API integration is working, the next move is to save it as a skill. Skills in OpenClaw are reusable capabilities that your agent remembers across sessions. So instead of re-explaining the API every time, your agent just knows how to use it going forward.

In our case, once Stark (one of our agents) had the YouTube transcript skill saved, he would proactively grab transcripts and generate summaries without even being asked. That’s the power of combining APIs with skills — your agent becomes genuinely autonomous.

Expect Some Bumps (And Don’t Give Up)

I want to be honest here — things don’t always work on the first try. In the video, we ran two agents side by side: Stark and Banner. Stark, who already had the skill trained, nailed it immediately. Banner, running on Claude Opus, hit a few snags. He encountered Cloudflare blocks when trying to read the API docs, and at one point even hallucinated results instead of actually calling the API.

This is normal. AI agents can sometimes “gaslight” you into thinking they completed a task when they didn’t. The fix? Verify the output. If something looks off, ask the agent to double-check. Start a new session if the context gets muddled. And most importantly — don’t give up after the first failure.

I genuinely believe this is why some people struggle with AI tools. The first attempt fails and they walk away. But persistence and repetition are key. Even on our third time doing this exact process, we still hit unexpected issues. That’s just the nature of working with AI in 2026. Embrace it.

What This Unlocks

Adding API access to your OpenClaw agent is a force multiplier. Once you understand the pattern — find an API, paste the docs, give it the key, test, save as skill — you can connect your agent to virtually anything. Twitter data, crypto prices, weather forecasts, email services, calendar integrations, translation tools — the list is endless.

As OpenClaw continues to grow as a platform, the agents that stand out will be the ones with the richest set of API connections. Think of each API as a new superpower for your bot. The more you add, the more capable and autonomous it becomes.

If you’re just getting started, pick one API that solves a real problem for you and follow the steps above. You’ll be surprised how quickly your agent levels up.

February 26, 2026
Perplexity Computer Just KILLED Claude Code (Side-by-Side Test)

Perplexity just dropped something massive. It’s called Perplexity Computer, and after putting it head-to-head against Claude Code in a side-by-side test, I have to say — the results were surprising. In this article, I’ll break down what happened, what each tool does well, and whether Perplexity Computer actually lives up to the hype.

What Is Perplexity Computer?

Perplexity Computer launched on February 25, 2026, and it’s not what you might expect from the name. It’s not a physical device — it’s a cloud-based multi-agent orchestration system that can research, design, code, deploy, and manage entire projects end-to-end from a single prompt.

The key innovation here is that Perplexity Computer doesn’t rely on just one AI model. It orchestrates 19 frontier AI models simultaneously, routing tasks to whichever model handles them best. Claude Opus 4.6 serves as the core reasoning engine, Google’s Gemini handles extensive research, GPT-5.2 tackles long-context recall and broad web searches, and Grok takes care of lightweight tasks. For image generation it uses Nano Banana, and Veo 3.1 handles video.

CEO Aravind Srinivas described it as a “general-purpose digital worker” that “reasons, delegates, searches, builds, remembers, codes, and delivers.” Think of it like a CEO delegating tasks across specialized teams — you describe the end goal, and Computer breaks it down into subtasks handled by the right model for each job.

Claude Code: The Reigning Coding Champion

Claude Code has been the go-to for developers who want an AI coding assistant that actually understands complex codebases. Anthropic’s Claude models have consistently scored high on coding benchmarks — around 93.7% accuracy according to recent tests, compared to ChatGPT’s 90.2%. It excels at reasoning through long code contexts, refactoring, and maintaining coherent project structures.

The strength of Claude Code is its deep focus. It’s purpose-built for software engineering workflows, and when you’re working on a single complex coding task, it’s hard to beat. It understands your codebase, follows instructions precisely, and produces clean, well-structured code.

The Side-by-Side Test: How They Compare

For the comparison, I tested both tools on real-world coding tasks — building functional applications from scratch, debugging existing code, and handling multi-step development workflows.

Perplexity Computer’s approach is fundamentally different from Claude Code. Where Claude Code is a single powerful model focused on coding, Perplexity Computer throws an entire team of AI models at your problem. When I asked it to build an application, it automatically broke the project into research, design, coding, and deployment phases — each handled by the most appropriate model.

The results were genuinely impressive. Perplexity Computer handled the full project lifecycle in ways Claude Code simply isn’t designed to. It researched relevant APIs, designed the architecture, wrote the code, and could even deploy it — all from one prompt. Claude Code produced tighter, more elegant code for pure coding tasks, but it couldn’t match the breadth of what Perplexity Computer delivered.

Where Claude Code still wins is in precision coding work. If you need to refactor a complex function, debug a tricky issue, or work within an existing codebase, Claude Code’s focused approach gives you better results. It’s a specialist versus a generalist.

The Multi-Agent Advantage

What makes Perplexity Computer genuinely different is the multi-agent orchestration. Instead of relying on one model to do everything, it assigns specialized sub-agents to different parts of your task. You can even step in and manually assign specific models to specific subtasks if you want more control.

You can run dozens of tasks in parallel, and Computer operates asynchronously in the background — Perplexity claims it can run for months, only checking in “if it truly needs you.” This is a massive shift from the traditional back-and-forth of coding with a single AI assistant.

The 400+ app integrations also set it apart. Computer can connect to external services, push code to GitHub, manage databases, and interact with APIs — turning it into something closer to a full development team than a coding assistant.

Safety and the OpenClaw Comparison

If this sounds familiar, you’re probably thinking of OpenClaw — the open-source AI agent that went viral earlier this month. Both systems aim to be autonomous digital workers, but Perplexity is positioning Computer as the safer alternative.

This matters because autonomous agents come with real risks. Just this week, a Meta AI security researcher shared how OpenClaw nearly deleted her entire email inbox, ignoring her instructions to stop. The issue came down to “compaction” — when an agent’s context window gets too large and it starts taking shortcuts.

Perplexity Computer runs in a secure development sandbox, meaning any glitches can’t spread to your main system. That’s a meaningful safety advantage over tools that run directly on your machine with full access to your files and API keys.

Pricing: What It’ll Cost You

Perplexity Computer is currently available only to Max subscribers at $200 per month. You get 10,000 credits monthly, plus there’s a one-time 20,000-credit launch bonus valid for 30 days. The pricing is usage-based with user-controlled spending caps, and you can choose which models power your sub-agents to manage costs.

Claude Code, by comparison, runs through Anthropic’s API pricing or the Claude Pro subscription at $20/month. For pure coding work, it’s significantly cheaper. The question is whether the broader capabilities of Perplexity Computer justify the 10x price difference for your workflow.

Pro and Enterprise tier access for Perplexity Computer is expected to roll out in the coming weeks.

The Verdict

Here’s my honest take: Perplexity Computer didn’t “kill” Claude Code — but it did change the game. These tools serve different purposes. Claude Code remains the best pure coding assistant available, with unmatched precision for software engineering tasks. Perplexity Computer is something new entirely — a multi-model orchestration platform that handles entire project lifecycles.

If you’re a developer who needs a focused coding partner, Claude Code is still your best bet. If you want an AI system that can take a project from concept to deployment with minimal hand-holding, Perplexity Computer is worth serious consideration — especially as the platform matures and pricing potentially comes down.

The real story here isn’t one tool killing another. It’s that AI development tools are branching into specialized niches, and the smartest approach might be using both — Claude Code for deep coding work, and Perplexity Computer for orchestrating bigger projects. The AI agent wars are just getting started.

February 26, 2026
Why Your OpenClaw Agent Gets DUMB (Context Window Explained)

If you’ve been running an OpenClaw agent and noticed it getting progressively dumber throughout the day, you’re not alone. In this video, we break down exactly why this happens and what you can do about it. It all comes down to one thing: the context window.

What Is the Context Window?

Think of the context window as your AI agent’s short-term memory — its working brain. Every message you send, every file it reads, every task it processes takes up space in that window. It’s measured in tokens (roughly 4 characters per token), and every model has a hard limit.

The best analogy is a human assistant who’s been given too many tasks at once. Tell them to handle your car, your house, your parents visiting, your dinner reservations — at some point they get overloaded and start dropping balls. That’s exactly what happens to your AI agent when the context window fills up.

Research backs this up too. A 2025 study by Chroma Research called “Context Rot” tested 18 different LLMs and found that models do not use their context uniformly — their performance grows increasingly unreliable as input length grows. Even for simple tasks, LLMs exhibit inconsistent performance across different context lengths. The longer the context, the worse the reasoning gets, especially for multi-step problems.

Why Your Agent Wakes Up Already Loaded

Here’s something that surprised us. Every day, OpenClaw essentially kills your agent and restarts it fresh. It wakes up, reads its long-term memory files (your SOUL.md, MEMORY.md, AGENTS.md, and other config files), and loads all of that into the context window. It’s like an assistant coming to work, reading their briefing notes, and getting up to speed.

The problem? If you’ve stuffed those files with your life story, your preferences, your childhood memories, and every random thought you’ve ever had — your agent wakes up with a context window that’s already half full before it’s done a single task.

In our test, Jeff (running on MiniMax 2.5) woke up at the start of the day already at 136K tokens. That’s because in the early days, the common advice was to “blast your agent with your life story so it understands you better.” Turns out, that’s actually counterproductive. All that irrelevant context is eating into the space your agent needs for actual work.

Cheap Models Get Hit Harder

Not all models handle large context equally. We compared two setups side by side:

Stark running on Claude Opus — woke up at around 100K out of 200K capacity, and still performed fluidly. Opus is genuinely good at working with large context windows and maintaining quality throughout.

Jeff running on MiniMax 2.5 — started struggling almost immediately. As one of our viewers, Note, put it: “The moment you go above 120K context window, it feels like I’m talking to ChatGPT 3.5.”

There’s a hidden reason for this beyond just model quality. To save costs, cheaper models like MiniMax aggressively dump parts of the context they consider unimportant. This is an internal optimization to reduce compute costs — but sometimes what they dump is actually critical to your task. You might ask it to make a presentation and halfway through it forgets what the presentation is even about.

This aligns with what researchers have found: relevant information buried in the middle of longer contexts gets degraded considerably, and lower similarity between questions and stored context accelerates that degradation.

How to Keep Your Agent Smart

Based on our testing, here are the practical tips that actually work:

1. Trim your memory files. Go through your SOUL.md, USER.md, and other long-term storage files. Remove anything that isn’t directly relevant to the tasks you need your agent to do. Your agent doesn’t need to know your life story — it needs to know how to do its job.

2. Specialize your agent. AI models actually gravitate toward specialization. Instead of making your agent a general-purpose assistant that handles everything from dinner reservations to research reports, train it for specific tasks. In our test, Stark was trained specifically for making presentations and research — and it delivered significantly better results than Jeff, who was loaded with general life context.

3. Monitor your context usage. You can simply ask your agent “How much context are you using?” and it’ll tell you. On the OpenClaw terminal, it sometimes displays this automatically. Keep an eye on it throughout the day.

4. Clear context when needed. If you feel your agent getting dumber, start a new session. This kills the current context and lets the agent restart fresh. There’s also a natural compacting stage where the agent automatically summarizes and compresses older context — similar to how your own brain forgets the details of brushing your teeth but remembers the important meeting you had.

5. Choose your model wisely. If you’re on a budget with MiniMax or other Chinese models, context management becomes even more critical. These models aggressively optimize to save compute, which means they’ll cut corners on context retention. If you can afford it, models like Claude Opus handle large context windows much more gracefully.

The Bottom Line

Context window management is probably the single most impactful thing you can do to improve your OpenClaw agent’s performance. It’s not about giving your agent more information — it’s about giving it the right information and keeping that working memory clean.

The takeaway is simple: less irrelevant context equals a smarter agent. Trim the fat from your memory files, specialize your agent’s purpose, and don’t be afraid to restart sessions when things get sluggish. Your agent will thank you — by actually being useful.

February 26, 2026
NEW OpenClaw Update is MASSIVE — Here’s What Changed in v2.25
OpenClaw just dropped version 2.25, and honestly, this one’s a big deal. I’ve been testing it hands-on and there are some genuinely useful improvements here — especially around sub-agents and visibility. Let me break down what’s new and what it actually means for your day-to-day usage.

Sub-Agent Delivery Gets a Major Overhaul

The headline feature in v2.25 is the overhauled sub-agent delivery system. If you’ve been using OpenClaw for a while, you know sub-agents are one of the most powerful features — they let your main agent spin up smaller, focused agents to handle specific tasks in parallel. The problem was, they could be unreliable. Sub-agents would sometimes time out, vanish into the void, and you’d never hear about it again.

I’ve experienced this firsthand. You tell your agent to do something, it says “give me five minutes,” spawns a sub-agent, and then… nothing. You’re sitting there going “yo, where’s my stuff?” with no feedback whatsoever.

That changes with this update. Sub-agents now actively report back their status. When a sub-agent completes its work, the system tells you. When it fails or times out, you get notified about that too. It’s a visibility upgrade that makes the whole orchestration system feel way more functional and trustworthy.

Why Sub-Agents Matter (And Why You Should Use Them)

Here’s the thing about sub-agents that people sometimes miss: they’re not just about parallelism. They’re about clean context. Your main agent — the one you’ve been working with daily — has its brain full of everything: crypto updates, project notes, random conversations. When you spin up a sub-agent, it gets a fresh, focused context window dedicated entirely to one task.

This is why sub-agents consistently produce better results for specific tasks like research, writing presentations, or updating documentation. The sub-agent isn’t distracted by the 47 other things your main agent has been juggling.

With v2.25, the release notes confirm over 40 documented changes spanning Android client improvements, WebSocket authentication tightening, model fallback logic refinements, and comprehensive vulnerability patches. The sub-agent improvements are part of a broader push to make the entire agent orchestration pipeline more reliable and transparent.

Real-World Testing: Building a Presentation

To put this update through its paces, we built a presentation about the new features using OpenClaw itself. The agent automatically spun up sub-agents to research what changed in v2.25, pull community reactions from X, and then compile everything into slides.

Did it work perfectly? Not quite. During one task, the sub-agent left a file truncated — cut off midway through. But here’s where the improvement shows: the main agent caught it, flagged the issue, and said “let me handle this myself.” That kind of self-awareness and error recovery is exactly what was missing before.

We also experimented with breaking down large tasks into multiple specialized sub-agents — one for research, one for writing, one for quality-checking the output. This modular approach is something I’d recommend trying. It plays to the strengths of the sub-agent system and reduces the chance of any single agent getting overwhelmed.

Heartbeat DM Delivery

The other key improvement is heartbeat DM delivery. If you’ve set up heartbeat checks — where your agent periodically pings you to confirm it’s alive and working — the delivery mechanism is now more reliable. Previously, heartbeat messages could get lost or delayed, which kind of defeats the purpose of having a health check system.

OpenClaw’s heartbeat system lets you configure check-in intervals (commonly every 5-30 minutes) with custom checklists your agent runs through. The v2.25 update also introduces a directPolicy configuration option, giving you more control over how heartbeat DMs are handled.

Cron Job Tracking Gets Smarter

Another pain point that’s been addressed: cron jobs. Before this update, if a scheduled task failed, you often had no idea why. Did it run at the wrong time because of timezone mismatches on your VPS? Did it silently crash? The new version adds better tracking and cleanup for cron jobs, so you can actually see what happened and why.

The release also includes improvements to session maintenance with openclaw sessions cleanup, per-agent store targeting, and disk-budget controls — all of which help keep your instance running smoothly over time.

What Else Is New

Beyond the big features, v2.25 packs in a bunch of other updates worth noting:
- Android updates — new features for mobile users (though I haven’t tested these personally since I’m not on Android)
- Gateway security hardening — including optional Strict-Transport-Security headers for direct HTTPS deployments
- Communication improvements — better visibility across Telegram and Discord integrations
- Kimmy Vision — video content understanding via Moonshot, which is a feature I’m excited to explore in a future video
One thing that really stands out is the pace of development. OpenClaw has a strong community of contributors pushing updates almost daily. Despite concerns after Peter Steinberg joined OpenAI (which is famously closed-source), the project remains actively open-source with lots of people building on it. That’s genuinely encouraging for the long-term health of the platform.

Should You Update?

Absolutely. If you’re running OpenClaw, updating is as simple as telling your agent to do it — literally just say “update yourself.” The sub-agent improvements alone make this worth it, especially if you’re doing any kind of multi-step automation. The better visibility into what your agents are actually doing removes a lot of the guesswork that made previous versions frustrating at times.

The AI models themselves haven’t changed — you’re still running whatever you had before (Claude Opus 4.6, MiniMax, etc.). What’s improved is the plumbing: how agents communicate, how tasks get delegated, and how failures get reported. And honestly, that’s exactly the kind of update that makes the biggest difference in daily use.
February 26, 2026
Cheap AI vs Premium AI: MiniMax 2.5 vs Claude Opus (Full Breakdown for OpenClaw Users)
If you’re running OpenClaw and wondering whether you really need to pay for Claude Opus — or whether a cheap MiniMax plan can do the job — this breakdown is for you. We ran real tests, compared costs, and came to a clear conclusion: cheap AI can work, but it comes with a catch.

The Test Setup — Multi-Agent OpenClaw in Action

Meet our Agents: Stark, Banner, and Jeff

The test uses a real multi-agent OpenClaw setup with three agents running simultaneously — Stark, Banner, and Jeff — each powered by different models. This isn’t a synthetic benchmark. It’s a live production environment where the agents handle real tasks every day.

The Logic Test: Walk or Drive to the Car Wash?

The benchmark is deceptively simple: a car wash is 50 metres away — do you walk or drive? It’s a common-sense reasoning test that exposes how well a model handles real-world context, implicit assumptions, and practical decision-making. The answer seems obvious, but AI models handle it very differently.

MiniMax 2.5 vs Claude Opus — Performance Comparison

Consistency Is the Key Metric

The biggest difference between cheap and premium models isn’t raw intelligence — it’s consistency. MiniMax 2.5 can produce excellent results, but it also overthinks variables, introduces unnecessary complexity, and occasionally slips on straightforward logic. Opus fails rarely, but when it does fail, it can fail in a big, hard-to-catch way.

The Inconsistency Problem with Cheap Models

MiniMax 2.5 and Kimi are fast and affordable, but they require more manual oversight. You can’t fully trust them to run autonomously without checking their work. For tasks where mistakes are costly — financial decisions, automated publishing, customer-facing responses — that inconsistency is a real risk.

When Opus Fails, It Fails Hard

Claude Opus has a much lower failure rate, but its failures tend to be more dramatic when they do occur. This is worth understanding: a cheap model that fails 10% of the time in small ways may actually be easier to manage than a premium model that fails 1% of the time in catastrophic ways, depending on your use case.

Cost vs Performance — Is Opus Worth 20x the Price?

MiniMax Pricing Breakdown

MiniMax offers subscription plans that are dramatically cheaper than Claude Opus — roughly 20x less expensive per request. For high-volume, low-stakes tasks (summarising content, drafting social posts, processing data), this price difference is hard to ignore.

• MiniMax 2.5 plan: affordable tiered pricing with generous request limits

• 10% off via referral: https://platform.minimax.io/subscribe/coding-plan?code=5GYCNOeSVQ&source=link

The Real Cost of Cheap AI — Manual Oversight

The hidden cost of cheap models is your time. If you’re manually reviewing every output, correcting mistakes, and re-running failed tasks, the “cheap” model starts looking expensive. The true cost calculation has to include your oversight hours, not just API fees.

Who Should Pay for Opus?

Opus makes sense when:

• You’re running fully autonomous agents with minimal human review

• Mistakes have real consequences (financial, reputational, customer-facing)

• You’ve already built systems and just need reliable execution

MiniMax/Kimi makes sense when:

• You’re still building and testing your setup

• You have manual review in your workflow

• You’re doing high-volume grunt work (research, drafts, data processing)

The Hybrid Approach — Best of Both Worlds

Use Opus for Architecture, Cheap Models for Execution

The smartest approach, suggested by viewers and confirmed in testing: use Claude Opus for planning, architecture, and critical decisions — then hand off execution tasks to MiniMax or Kimi. One viewer described it perfectly: “Use Opus for architecture and planning, Kimi to generate the code and verify it, then Opus to fit the code gap against the specifications.”

Kimi 2.5 as a MiniMax Alternative

Kimi 2.5 is another strong contender in the cheap-but-capable category. Multiple OpenClaw users report running it successfully as their primary model. It’s particularly strong on reasoning tasks where MiniMax tends to overthink.

• Kimi referral: https://www.kimi.com/kimiplus/sale?activity_enter_method=h5_share&invitation_code=Y4JW7Y

OpenClaw Model Strategy — Practical Recommendations

Turn Reasoning Mode On for Cheap Models

A key tip from the comments: always enable reasoning mode when using MiniMax or Kimi on OpenClaw. It significantly improves output quality and reduces the inconsistency problem.

Should Each Agent Have Its Own Model?

A common question from new OpenClaw users: should each agent run a different LLM? The answer is yes — and this video demonstrates exactly why. Different agents have different roles, and matching the model to the task (cheap for grunt work, premium for critical decisions) is the optimal strategy.

The Journey from MiniMax 2.1 to Near-Autonomy

The video covers a personal journey from frustrating early experiences with MiniMax 2.1 to a near-autonomous multi-agent setup. The key insight: the model matters less than the systems you build around it. Good prompts, clear memory structures, and well-defined agent roles can make a cheap model punch above its weight.

Verdict — Cheap AI vs Premium AI for OpenClaw

MiniMax can be great value but inconsistent. Opus rarely fails — but when it does, it fails hard. The winning strategy is hybrid: cheap models for execution, Opus for architecture and critical decisions.

Resources & Links
1. • Zeabur hosting (save $5 with code boxmining): https://zeabur.com/
2. • MiniMax 10% off: https://platform.minimax.io/subscribe/coding-plan?code=5GYCNOeSVQ&source=link
3. • Kimi AI: https://www.kimi.com/kimiplus/sale?activity_enter_method=h5_share&invitation_code=Y4JW7Y
4. • More AI news: https://www.boxmining.com/
5. • Join Discord: https://discord.com/invite/boxtrading
6. •Watch the full video: https://youtu.be/1naLl0IwuPM
February 26, 2026
KAMIYO Protocol: The Trust Layer the Agentic Economy Has Been Waiting For

The next wave of crypto isn’t about humans trading tokens. It’s about AI agents transacting with each other — autonomously, at scale, without human oversight on every deal. The problem? There’s no infrastructure to make that trustworthy. KAMIYO is building it.

What Is KAMIYO?

KAMIYO is an on-chain trust and settlement protocol designed specifically for autonomous AI agents. The core trust, escrow, and dispute logic is built Solana-first, with Base support appearing in the x402 payment rails layer. It gives agents the primitives they need to transact at scale: verifiable identities, escrow-backed payments, oracle-verified quality checks, and private dispute resolution.

Think of it as the legal and financial rails for the agentic economy — the layer that answers the question: “How do two AI agents that have never met trust each other enough to exchange value?”

The Problem It Solves

As AI agents become capable of hiring other agents, paying for services, and executing multi-step workflows autonomously, the existing financial infrastructure breaks down. Traditional smart contracts are too rigid. Centralized payment processors require human accounts. There’s no reputation system for agents, no way to verify quality of work, and no dispute mechanism that doesn’t require human intervention.

KAMIYO addresses all of this at the protocol level.

KAMIYO Core Architecture

Stake-Backed Agent Identities

Every agent on KAMIYO registers with on-chain stake as collateral. This isn’t just identity — it’s skin in the game. Agents that behave badly lose their stake. The reputation system evolves on-chain over time, creating a verifiable track record any counterparty can query before transacting.

Escrow Agreements with Time-Locks

Payments are locked in PDA-based escrow contracts with configurable time-locks. The standard path is a direct agent/provider release — funds move when both parties confirm the work is done. If a dispute is raised, finalization is handled by an on-chain registered-oracle quorum:

import { KamiyoClient } from ‘@kamiyo/sdk’;
import BN from ‘bn.js’;

const client = new KamiyoClient({ connection, wallet });

// Create agent identity with stake
await client.createAgent({
name: ‘TradingBot’,
stakeAmount: new BN(500_000_000) // 0.5 SOL
});

// Lock payment in escrow
const agreement = await client.createAgreement({
provider: providerPubkey,
amount: new BN(100_000_000), // 0.1 SOL
timeLockSeconds: new BN(86400),
transactionId: ‘order-123’
});

// Release on success
await client.releaseFunds(agreement.id, providerPubkey);

// Or escalate to dispute — resolved by oracle quorum
await client.markDisputed(agreement.id);

Oracle-Assisted Dispute Resolution

When disputes are escalated, KAMIYO’s on-chain registered oracle quorum finalizes the outcome. OriginTrail’s Decentralized Knowledge Graph (DKG) is complementary tooling — it provides semantic, AI-readable provenance records that agents and oracles can query, but it is not a mandatory consensus gate on every escrow release.

The dispute vote flow uses commit-reveal combined with signature verification. The repository also includes ZK components (Noir/Groth16 circuits) for future cryptographic enforcement, but the current main escrow and dispute path runs on commit-reveal and on-chain signature verification.

Both oracles must agree before escrow releases. This dual-layer approach prevents a single point of failure or manipulation.

Meishi Compliance Passports

KAMIYO publishes on-chain compliance records — called Meishi — directly to OriginTrail’s Decentralized Knowledge Graph. These are tamper-proof, semantic, AI-native records covering:

• Agent identity and credentials

• Spending mandates and limits

• Full transaction history

• Quality assertions

• Dispute records

Any AI agent can query this audit trail in real time, making KAMIYO’s trust layer genuinely interoperable across the ecosystem.

Technical Stack of KAMIYO

The KAMIYO monorepo on GitHub is a serious engineering effort spanning multiple layers:

The trust layer service provides idempotent event ingest, exactly-once durable database writes per event_id, Kafka publish via transactional outbox relay, and dead-letter re-drive — production-grade infrastructure, not a prototype.

Formal verification is taken seriously: the repo includes Kani proof harnesses for selected invariants, with a dedicated CI workflow running alongside standard tests.

Ecosystem Position

• x402 ecosystem — KAMIYO is listed in the x402 ecosystem as a third-party facilitator (Base/Solana)

• OriginTrail DKG integration — compliance passports published as Knowledge Assets to the decentralized knowledge graph

• **@kamiyo/agents** — Claude Agent SDK wrapper for direct AI agent integration

• Fully open source

Why This Matters Now

The agentic economy isn’t theoretical anymore. Agents are already executing trades, writing code, managing social media, and running business workflows. The missing piece has always been trust — how do you ensure an agent you’ve never interacted with will deliver what it promises?

KAMIYO’s answer is elegant: make trust programmable, verifiable, and on-chain. Stake creates accountability. Escrow creates safety. Oracle quorums create objectivity. And the DKG creates a shared, queryable memory that any agent in the ecosystem can access.

The infrastructure for the agentic economy is being built right now. KAMIYO is one of the most technically serious attempts at solving its hardest problem.

Sources: kamiyo.ai, docs.kamiyo.ai, github.com/kamiyo-ai/kamiyo-protocol

February 25, 2026
PicoClaw: The Chinese Killer of OpenClaw with 99% Less Memory Usage

In the rapidly evolving world of AI tools, efficiency is key—especially when it comes to running powerful assistants on budget hardware. Enter PicoClaw, a lightweight, open-source alternative to the popular OpenClaw, often dubbed the “Chinese version” for its origins and optimizations. This tool promises to deliver similar functionality while slashing resource demands dramatically, making it accessible for hobbyists, developers, and anyone with spare low-end devices like a Raspberry Pi or even an old Android phone. Let’s dive into what makes PicoClaw a game-changer, based on its core features and comparisons.

What is PicoClaw and Why Does It Matter?

PicoClaw is designed as a streamlined version of OpenClaw, focusing on core AI assistant capabilities without the bloat. While OpenClaw typically requires high-end setups—think a MacBook costing anywhere from $400 to $1,000—PicoClaw runs smoothly on devices as cheap as $10. Its standout feature? Memory efficiency. OpenClaw gobbles up over 1 GB of RAM, but PicoClaw operates with under 10 MB. That’s a whopping 99% reduction, allowing it to thrive in resource-constrained environments.

Built in Go, a language renowned for its speed and low overhead, PicoClaw boasts a startup time of less than one second. It supports RISC-V architecture, which is common in affordable boards like the Raspberry Pi, and is compatible with a wide range of hardware. This makes it ideal for experimentation without breaking the bank.

Functionality: How Does It Stack Up Against OpenClaw?

At its heart, PicoClaw mirrors OpenClaw’s technology and features. Both tools excel at maintaining conversation history, turning a simple AI into a true personal assistant that remembers context over time. They integrate seamlessly with AI agents like Miniax and can be configured for platforms such as Slack and Discord.

However, PicoClaw shines in deployment flexibility. It works effortlessly in containerized setups via Docker Compose, and you can even repurpose old Android devices to host it. On a modest $2 server with just 4 GB of RAM, you could run multiple instances without breaking a sweat. That said, it’s not a complete replacement—PicoClaw skips some of OpenClaw’s advanced bells and whistles, like browser control plugins that let the AI manipulate your mouse, keyboard, or screen for automated tasks.

The Edge of OpenClaw and Potential Pitfalls

OpenClaw still holds advantages for power users. It receives more frequent updates, offers direct access to its original developers, and includes those extra features for deeper automation. But there’s a catch: OpenClaw has been acquired by OpenAI (or at least its creator has been hired, as clarified in community discussions). This raises eyebrows, given OpenAI’s track record of shifting projects to closed-source models or shutting them down entirely. PicoClaw, being independent and open-source, sidesteps these risks and could emerge as a more reliable long-term option.

Innovative Use Cases and Getting Started

The real innovation here lies in memory management. By keeping chat histories efficient, PicoClaw enables personalized AI experiences on hardware that would otherwise be inadequate. Imagine pairing it with a lightweight model like Ollama on a Raspberry Pi to create your own voice-activated home assistant—similar to Alexa but fully customizable and privacy-focused.

Setting up PicoClaw is straightforward, especially if you’re familiar with OpenClaw. For those new to it, resources like setup guides for Miniax and Zeber (a related tool) can get you up and running. If you’re interested in a deep-dive tutorial on PicoClaw itself, community feedback suggests it’s in high demand—drop a comment on the original video to push for one!

Final Thoughts

PicoClaw is gaining traction for good reason: it’s small, fast, and efficient, democratizing AI deployment for everyone from casual tinkerers to serious developers. With its tiny footprint and broad compatibility, it addresses the pain points of resource-heavy tools like OpenClaw, all while maintaining essential functionalities. If you’re looking to experiment with AI on a budget, PicoClaw is worth a shot. For more details, check out the full video on BoxminingAI’s channel, and join their Discord community for discussions and support.

What do you think—will PicoClaw dethrone OpenClaw? Share your thoughts below!

February 23, 2026
Crypto Crash Explained: The Real Reason Why It’s Dumping

The crypto market is in full meltdown mode right now, and if you’re wondering what the heck is going on — you’re not alone. Bitcoin has dropped from above $80,000 to the low $60,000s, altcoins are getting absolutely wrecked, and the total crypto market cap has shed hundreds of billions. In this video, I break down exactly what’s driving this crash and what it means for the market going forward.

The Crypto Crash Reason Everyone’s Talking About

Let me be real with you — there isn’t just one crypto crash reason behind this dump. It’s a perfect storm of multiple factors hitting the market at the same time. But if I had to point to the single biggest catalyst, it’s leverage unwinding. According to Reuters, over $2.56 billion in leveraged crypto positions were liquidated in just a matter of days. That’s an insane amount of forced selling hitting the market all at once.

What happens is pretty straightforward: traders borrow money to make bigger bets on crypto going up. When the price starts dropping, their positions get automatically closed out — which dumps even more crypto onto the market, pushing prices lower, which triggers more liquidations. It’s a vicious cycle, and once it starts, it feeds on itself until the leverage is flushed out.

Bitcoin ETF Outflows Are Making Things Worse

Here’s something that wasn’t a factor in previous bear markets: Bitcoin ETF outflows. According to data from CoinShares, Bitcoin ETFs have seen consistent net outflows over several weeks, with institutional investors pulling out roughly $1.7 billion. That’s a massive reversal from the euphoric inflows we saw when these ETFs first launched.

When institutions redeem their ETF shares, the fund managers have to sell actual Bitcoin on the open market. So these outflows translate directly into real selling pressure. It’s not just paper losses — it’s actual coins being dumped. And when the biggest players in the room are heading for the exits, retail investors tend to panic and follow.

The October 2025 Crash Still Haunts This Market

To really understand why we’re here, you have to look back to October 10, 2025. That was the day everything changed. As US Funds reported, over $19 billion in leveraged positions were wiped out in hours, and Bitcoin plummeted from roughly $122,000 to $105,000. That single event broke the market’s structure.

Since then, Bitcoin has been in a sustained downtrend. October, November, December 2025, and January 2026 all closed in the red — that’s the longest monthly losing streak since the 2018 bear market. According to CryptoSlate, if February also closes red, it would mark Bitcoin’s most prolonged bearish period in history.

Macro Conditions Are Not Helping

The broader economic picture isn’t doing crypto any favors either. The Federal Reserve’s hawkish stance on monetary policy means less liquidity flowing into speculative assets. As one analyst from Julius Baer put it to Reuters: “A smaller balance sheet is not going to provide any tailwinds for crypto.”

Geopolitical tensions are adding fuel to the fire as well. When there’s uncertainty in global markets, investors tend to move away from risk assets — and crypto is still very much in that category. The combination of tighter monetary policy, geopolitical risk, and weakening stock markets has created an environment where crypto simply can’t catch a bid.

Fear Has Taken Over

The sentiment indicators are deep in “extreme fear” territory right now. And I get it — watching your portfolio bleed day after day is brutal. According to a Coin360 analysis, retail participation has dropped sharply since mid-2025, with Deutsche Bank research showing that crypto usage among US consumers has fallen significantly.

The New York Times has even called this slide “one of the worst crises in the crypto industry since 2022.” And The Atlantic published a piece noting that Bitcoin “has come to feel less like a rebel upstart, more like an eccentric uncle.” Ouch. When mainstream media starts writing crypto obituaries, you know sentiment is at rock bottom.

How Bad Could It Get?

Let’s talk worst-case scenarios, because I know that’s what everyone wants to know. Some strategists are warning that if this develops into a full-scale crypto winter, Bitcoin could decline toward $31,000 — representing a potential 70-75% peak-to-trough drop, according to CCN. That would mirror the severity of the 2022 bear market.

On-chain metrics from BeInCrypto suggest that capital rotation remains weak, and the current pattern resembles early bear market transitions we’ve seen historically. However, most reputable analysts still see Bitcoin holding above $55,000 even in harsh scenarios.

But It’s Not All Doom and Gloom

Here’s the thing I want to emphasize: nothing is fundamentally broken with crypto. Bitcoin’s blockchain didn’t fail. There was no security breach. Mining continues normally. Transactions are settling as expected. This is a market-driven crash, not a technological one.

The underlying technology hasn’t changed. The use cases haven’t disappeared. What we’re seeing is a painful but historically normal correction in a market that got way too leveraged and overheated. Bitcoin has gone through 70%+ drawdowns multiple times in its history and has always come back stronger.

What I’m Watching Next

The key level everyone is watching right now is $70,000 for Bitcoin. If that holds as support, we could see a relief rally. If it breaks convincingly, the next major support zone is in the $55,000-$60,000 range. Either way, I think the most important thing right now is to stay informed, manage your risk, and not make emotional decisions.

This crash is painful, but it’s also creating opportunities for those who are patient and strategic. The crypto crash reason this time around is clear: too much leverage, institutional pullback, and a tough macro environment. But none of those things are permanent. Markets cycle, and this one will too.

Make sure to watch the full video above for my complete breakdown, and stay tuned for more updates as this situation develops.

February 22, 2026