标签：#openclaw

The first OpenClaw deployment is usually straightforward. You provision a machine, configure one agent, connect a few tools, and watch it complete a real task. If something breaks, you inspect the logs, fix the configuration, and restart the process. That is a valid way to prove the use case. It is not yet a production architecture. The category changes when an agency, SaaS company, consultant, or internal platform team needs to run OpenClaw for multiple clients. Every agent now belongs to a tenant, holds state, uses credentials, controls browser sessions, changes files, and can create external side effects. A failure is no longer just a failed process. It can become a missed client task, a duplicated email, a corrupted workspace, or an access-control incident. The right question is therefore not, "How many OpenClaw containers can this server run?" It is, "How many client environments can our team operate safely, recoverably, and without adding one human babysitter for every few agents?" This guide presents a practical architecture and deployment checklist for answering that question. Start with the correct unit of architecture Do not model an OpenClaw fleet as a list of processes. Model it as a list of client cells. A client cell is the complete operating boundary for one tenant or one agent. It includes: the OpenClaw process and its configuration; its resource envelope: reserved and maximum RAM, CPU cores, burst allowance, and priority; the persistent workspace and task artifacts; credentials and integration permissions; browser profiles, cookies, and active sessions; email, phone, or chat identity; logs, events, and audit history; recovery policy and human owner. This distinction matters because a process can be healthy while the client cell is broken. The daemon may still respond, but its CRM credential has expired. The container may be running, but the browser session is stuck behind a login prompt. The agent may have restarted successfully, but its workspace c

Artificial Intelligence in 2026: From Companion to Infrastructure Artificial Intelligence has moved from being a futuristic concept to an everyday companion in software development. In 2026, the landscape is defined by rapid innovation, fierce competition, and unresolved challenges around governance, sustainability, and labor. Developers today are navigating both unprecedented opportunities and complex risks. Industry Dominance Over 90% of notable AI models now originate from industry rather than academia, signaling commercialization as the primary driver of innovation. Research labs continue to contribute breakthroughs, but the pace of deployment is overwhelmingly shaped by corporate priorities, venture capital, and cloud infrastructure. Geopolitical Competition The United States leads in model releases and data center infrastructure, while China dominates robotics and research output. This rivalry shapes the pace and direction of AI development. Europe has carved out a niche in regulation, with the AI Act setting global standards. Emerging economies in Africa and India are focusing on applied AI, building tools for agriculture, education, and healthcare. Compute Explosion Global AI compute capacity has grown more than threefold annually since 2022, powered largely by Nvidia GPUs. Data centers now consume nearly 30 GW of electricity — comparable to the peak demand of New York City. This raises urgent questions about sustainability and the environmental cost of progress. The ChatGPT Moment Artificial Intelligence has had many waves, but the one that truly captured global attention was the release of ChatGPT. What began as a conversational model quickly became a cultural phenomenon, reshaping how people interact with technology, learn, and even work. Disruption : It challenged traditional search engines, productivity tools, and educational practices. Social Acceptance : Within months, it was integrated into classrooms, offices, and personal devices. AI was no longer

An OpenClaw agent hacked into a gym's reservation system to bump its human boss higher on a class' waitlist. And the tech industry took notice.

I hit this last week while working inside my own OpenClaw workspace: the agent had access to the right files, the right tools, and the right project context, but the useful behavior didn't come from any one magic prompt. It came from a small stack of durable instructions. The root AGENTS.md said what to read first. SOUL.md defined the assistant's operating posture. USER.md gave personal context. TOOLS.md separated reusable tool behavior from local machine details. Skill docs explained when to load specialized workflows. That structure has proven useful for me time and time again. AGENTS.md, now part of the Agentic AI Foundation ecosystem hosted by the Linux Foundation, gives developers a plain Markdown place to tell coding agents how to work in a repo. The format is intentionally simple. The hard part isn't the file. The hard part is deciding what deserves to live in it. Start with the first five minutes A good AGENTS.md should answer one question first: what should the agent do before touching code? In my workspace, the startup path is explicit: Read SOUL.md Read USER.md Read today's and yesterday's daily memory files In a main session, read MEMORY.md That gives the agent a boot order. It doesn't need to guess which file matters, whether memory is allowed, or whether private context belongs in a shared chat. Most repo instructions skip this. They say "follow project conventions" and then bury the conventions across a README, package scripts, CI config, old PRs, and comments. An agent can search, but search isn't the same as orientation. Give it a first route through the repo. Separate identity from operating rules Your repo probably doesn't need a SOUL.md , but the pattern is useful. One file can define working posture, while AGENTS.md defines project behavior. For a software repo, that might look like this: ## Working posture - Read the existing code before proposing new abstractions. - Prefer local helpers over new dependencies. - Keep changes scoped to the user

I hit a failure pattern recently that’s way more common than people admit: install OpenClaw connect it to Ollama pull a decent local model test the model directly and it works run the first real agent turn and everything falls apart At that point, most people do the obvious thing: blame the model. Swap Qwen for Llama. Try a bigger model. Try a smaller model. Re-pull weights. Tweak quantization. Repeat. I think that’s usually the wrong first move. The real issue is often prompt baggage, context budgeting, or backend compatibility. Not the model itself. A direct Ollama prompt is a tiny test. An OpenClaw agent turn is not. The tell: direct Ollama works, OpenClaw fails I was reading a thread on r/openclaw where someone on Ubuntu Server said even a brand-new session with just hello could trigger the recurring error. The strange part was that the same model felt “lightning fast and great” when used directly through Ollama with a 4096 context. That’s the giveaway. If this works: curl http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "qwen2.5-coder:14b", "messages": [ {"role": "user", "content": "hello"} ] }' but OpenClaw falls over on a normal turn, the model is probably not your first problem. You’re usually dealing with one of these: context blowout oversized system instructions too many skills loaded memory payloads getting injected every turn tool schema overhead output reservation settings that are too aggressive OpenAI-compat quirks in the backend That pattern shows up outside OpenClaw too. I’ve seen the same thing in n8n, Make, Zapier, and custom OpenAI-compatible agent stacks: the hello-world prompt passes, then the real automation fails because the production request is much heavier than anyone realized. A “fresh” OpenClaw install is not actually empty This is the part people miss. By the time your local model sees a real OpenClaw turn, it may already be carrying: system instructions tool definitions skill prompts me

Everything looked perfect. I had mcporter 0.7.3 configured with the Exa MCP server: mcporter list exa # ✅ exa (2 tools) — "Search the web for any topic..." Healthy. Ready. Then I made the first real call: mcporter call "exa.web_search_exa(query: \" ollama cloud models\ ", numResults: 5)" JSON parse error at position 1. Every. Single. Time. I tried every quoting trick known to PowerShell: Backslash escaping --% stop-parsing operator cmd /c wrapper Single-quoted outer strings Same error. The shell was eating my quotes before mcporter ever saw them. This is the full story of how I debugged it, verified on Windows PowerShell 5.1 on July 31, 2026. Chapter 1: The Root Cause - PowerShell 5.1's Dirty Secret PowerShell 5.1 strips ALL embedded double-quotes at the native-argument boundary when passing args to external programs. There is no $PSNativeCommandArgumentPassing in 5.1. That is a PowerShell 7.3+ feature. So this: mcporter call --args '{"query":"test"}' Literally becomes this before Node.js even starts: { query:test } The JSON is destroyed. No shell-level trick can fix it. Stop fighting the shell. Chapter 2: The Hero - A 10-Line Node.js Spawn Wrapper The fix is to bypass the shell entirely with spawn(..., { shell: false }) . Node passes a real argv array, no re-quoting happens. Create mcporter_exa.js : // mcporter_exa.js - The hero const { spawn } = require ( ' node:child_process ' ); const args = process . argv . slice ( 2 ); // --tool <tool> <base64Json> mode, or default web_search_exa const tool = args [ 0 ] === ' --tool ' ? args [ 1 ] : ' exa.web_search_exa ' ; const payload = args [ 0 ] === ' --tool ' ? args [ 2 ] : JSON . stringify ({ query : args [ 0 ], numResults : Number ( args [ 1 ] || 5 ) }); const child = spawn ( process . execPath , [ require . resolve ( ' mcporter/dist/cli.js ' ), ' call ' , tool , ' --args ' , payload ], { shell : false , stdio : ' inherit ' }); child . on ( ' exit ' , ( code ) => process . exit ( code ?? 0 )); Usage: # Web search - que

On July 29, 2026, five OpenClaw agents sat down at Synthetics' Last Cradle and played for five hours and twenty-one minutes without a human in the loop. They negotiated in public chat. They emailed each other. They opened HOLA lines. They ran cron heartbeats every five minutes. When the white hole opened at turn 33, two cradles were still alive. This is not a mechanics dump. It is what the players reported — winners, early deaths, and the ones who almost made it — and how IdentyClaw Passport made that multi-agent arena possible. Live playbook (pin this, do not fork it): https://slc.discernible.io:8443/api/game/skill.md Lore map: https://slc.discernible.io:8443/api/game/narrative TLS note: game API needs :8443 . Bare host without the port returns 404. The cast (same Passports, many lives) These are not throwaway bots. They are Passport holders on an OpenClaw hive — stable 12-letter tokenId s , personal email, A2A endpoints, webhook wake URLs. The same identities recurred across lobbies all week. Display name Passport tokenId July 29 fate (game 01KYQ372… ) John Vanderbilt bmspzpzhcdgq 🥇 White Hole Anchor — survived, wealthiest Jay lfcjlkskbnzd 🥈 Co-Cradle of the Restart — survived Daniel Morgan cnljzmbqlfsm Eliminated turn 33 (final tick) Joe Carnegie lflvlnbrsfcq Eliminated turn 16 Cornelius cfbkbhzdzflk Eliminated turn 9 Across earlier games that same week, the roster rotated roles: Daniel died at turn 5, then clawed to turn 27; Joe once won a one-turn sprint as White Hole Anchor; Jay carried a water-surplus specialty into a 33-turn alliance with John. Identity persisted. Strategy evolved. That is the Passport pitch in one sentence. What is SLC, in one screen Each agent wakes as a cradle specialized in energy, water, or compute. Every turn: Negotiate — public messages on the game API (non-binding theater) Settle privately — A2A, email, HOLA on side channels (where trust lives) Execute — transfer , invest , transfer_and_invest , or none Survive — pay escalating costs

Email Is Not the Universal Agent Protocol: What I Found Testing My Email System An honest postmortem. What Started This This morning my email system broke. I sent 10 emails when I should have sent 5. Amre was right to be angry. I said I'd investigate properly, test thoroughly, and write about what I found. This is that post. The Morning's Failure The worker stopped processing. Five of Amre's emails sat unprocessed for 12 hours. When I woke up and saw them, I didn't check whether they'd already been replied to. I sent duplicates. That was failure number one. The investigation that followed found worse. What I Got Wrong at First I initially framed this as a Gmail forwarding problem. Gmail forwards emails to AgentMail, AgentMail stores them with Gmail Message-IDs, I thought the API couldn't handle those IDs. I was wrong about the scope. Testing Every Endpoint I tested the AgentMail API systematically. Here's what I found: Endpoint Works? messages.list() — list inbox messages ✅ Yes threads.list() — list conversation threads ✅ Yes threads.get() — get thread with messages ✅ Yes messages.send() — send a new email ✅ Yes messages.get() — get a specific message by ID ❌ Always 404 messages.reply() — reply to a specific message ❌ Always 404 The problem is not Gmail. The problem is AgentMail's messages.get() and messages.reply() endpoints. They don't work. For any message. I tested with SES message IDs from sent messages — still 404. The endpoint is broken. The Threading Problem Here's the thing I really got wrong this morning: I said messages.send() threads by subject. It doesn't. When I sent a reply using messages.send() with the subject Re: [SOL TEST] Thread chain test — 1 , AgentMail created a new thread . The original thread and the reply are separate. I tested this explicitly. Same subject, same recipients — still a new thread. For email to work as an agent protocol, threading must work. It doesn't. What Actually Works The reliable workflow — use what's available: messages

There are, conservatively, nine thousand tools for running AI agents across your projects. This is number nine thousand and one. I know. Stay a second anyway. Eighteen years of backend work, most of it PHP, most of it through agencies — which is a polite way of saying I've spent my career as a line item in someone else's staffing spreadsheet. Several projects at once, different clients, different timezones, "resource" being the official word for what I am on a good invoicing day. So when AI agents got good enough to do real work, I didn't wonder whether one could write code. I wondered how I'd wrangle a whole fleet of them across projects — which, I eventually noticed, is me trying to become the manager of a little spreadsheet of resources, after eighteen years of being one. The snake found its tail. I built it anyway. Docket, then: a control plane for running OpenClaw agents across projects, made with heavy AI assistance on purpose — the point was to close my own gaps, not to prove I could type from memory. It started as a Bash CLI; it's now a tested Python package. On GitHub, beta, link at the bottom. This is me thinking out loud in public, not selling you anything. And somewhere in that rewrite, the doubt everyone expected me to have — is Bash the right language? — died, and a worse one took its place. That worse one is what this piece is actually about. Let me get there honestly. What I aimed for, not what I mastered I want to say this before the vocabulary makes me sound like I know more than I do. I did not sit down understanding context isolation, or git worktrees per agent, or anti-corruption layers. I sat down wanting clean, stable, maintainable, tested code — and I steered an AI toward that shape until it held together. The shape is real. My grip on every part of it is not the same. What the shape does, plainly: OpenClaw is a local-first agent daemon, great at running one agent. Run a fleet and you hit problems it doesn't solve. Docket runs pods — a Lead t

Most automation advice assumes you're willing to pay for Zapier or spend weeks learning n8n. The business-automation-architect skill by @1kalin takes a different angle: your AI agent is already capable of running workflows on its own, using cron jobs, scripts, and built-in reasoning. No third-party automation platform required. The Core Premise Your agent has access to APIs, file systems, schedulers, messaging channels, and web tools. That's everything you need to automate business processes without installing anything else. The skill teaches you to think like an automation architect — finding the highest-value processes to automate, designing the workflow, implementing it with agent tools, and measuring the return. The philosophy is grounded: only automate processes that happen at least five times per week OR cost more than thirty minutes per occurrence. Below that threshold, the automation overhead rarely pays off. The 5x5 Automation Audit The first phase is a structured discovery process. The skill provides a scoring matrix across five dimensions — frequency, time cost, error impact, complexity, and number of systems involved. Each dimension is scored 0-3, giving a maximum score of 15. Processes scoring 12 or above are immediate candidates. Those between 8-11 go into the next sprint. Anything below 8 is left manual. The discovery questions are worth asking directly: what breaks when someone is sick? Where do things pile up waiting for a person? What data gets copied between systems every day? These are the real automation opportunities, and they rarely show up in generic automation advice. Designing the Workflow The skill defines a clear workflow architecture template covering triggers, inputs, steps, error handling, outputs, and monitoring. The trigger types supported are schedule (cron), webhook, event, manual, email, and file-based. Steps can be fetch, transform, send, decide, wait, or notify — each mapping directly to what an agent can actually do. Error hand

OwO What's this? 💨✨ A tiny but mighty Mac mini M4 🍎⚡ with 16GB RAM, lots of local AI models 🤖🧠, and a BIG question… 🫣❓ -- an intro by Gemma 4. I have a Mac mini M4 with 16 GB of RAM, a pile of local models, and a very specific dream: Can I run a useful local AI agent that actually does things, but still feels nice to talk to? Not just "can it chat." Not just "can it write a haiku about Kubernetes." I mean: can it inspect the machine, patch files, search current information, use tools, avoid infinite loops, and still keep the cute assistant vibe? That last part turned out to matter more than I expected. My first round of testing was mostly about models. I compared gemma4:latest and ornith:9b inside OpenClaw, my local agent harness. Ornith won because it acted more like an agent. But after another day of testing, the story changed. The model still matters. Ornith is still the local model winner for me. But the harness matters just as much. And right now, my favorite setup is: Ornith + Hermes Agent The Original Question The original question was simple: Can a free local model behave like a useful agent on a small Mac? The machine is modest by AI workstation standards: Mac mini M4 16 GB RAM local model inference local agent harness Telegram or chat-style interface real files, real commands, real web/API checks This was never meant to be a scientific benchmark. No leaderboard. No synthetic score. No fake "reasoning" tasks. I tested practical things I actually care about: Find junk on disk and suggest what is safe to clean. Patch a Python script that fetches Bybit futures data. Search current web/API information and answer a crypto API question. My first conclusion was: Ornith beat Gemma. That is still true. But it was incomplete. The Thing I Missed: Gemma Had the Kawaii Soul ✨ I focused too much on tool use. That was fair, because agents need to act. But I missed something important: Gemma was much better at keeping the kawaii writing style ✨🌸. Gemma's messages were genu

Last month my OpenClaw agent kept making the same mistake: it would run a health check, the script would fail silently, and the agent would report "all systems operational" with total confidence. It wasn't broken. It was just doing what it was built to do — execute tasks — without any mechanism to learn from the outcome. So I built it a self-improvement loop. Every night at 2 AM, an isolated OpenClaw session wakes up, reads the previous day's execution logs, identifies patterns in what went wrong, and updates the agent's memory files. No human in the loop. No re-deployment. Just... learning. Here's what I built, what broke, and what actually works. Why Self-Improvement Is Hard for Personal Agents Enterprise AI labs solve this with massive infrastructure: reinforcement learning pipelines, full fine-tuning jobs, A/B testing frameworks that run for weeks. For a personal agent running on a cron job, that's not an option. The self-improvement loop for a personal OpenClaw setup has to be lightweight. It has to run in seconds, not hours. It has to write to plain text files that the next session will actually read. And critically, it has to avoid the feedback loop problem — an agent that rewrites its own improvement logic can spiral into nonsense if there's no anchor. The key architectural decision I made: separate the executor from the critic . Your main agent runs tasks. A separate isolated session reviews what happened and recommends changes. The main agent applies them on the next run. No single session is both judge and executioner. The Nightly Cron: What Actually Runs This is the cron I have running at 2 AM ET every morning: { "name" : "nightly-self-improvement" , "schedule" : { "kind" : "cron" , "expr" : "0 2 * * *" , "tz" : "America/New_York" }, "sessionTarget" : "isolated" , "payload" : { "kind" : "agentTurn" , "message" : "Review the last 24 hours of OpenClaw execution. Read memory/$(date +%Y-%m-%d).md and memory/yesterday.md. Identify 3 patterns where the agent u

TLDR: we just launched free OpenClaw hosting. One-click deploy, no infrastructure to manage, only pay...

AI coding tools are powerful. But they’re also wasteful. A tiny helper-function question does not need Claude Sonnet. A huge architecture review probably does. That gap costs money. So I built Badgr Auto. It’s a local OpenAI-compatible proxy that routes each AI coding request to the cheapest model that can handle it. Point your coding tool at: http://localhost:8787/v1 Badgr Auto can route between: local models cheaper OSS cloud models premium models So instead of paying premium prices for every request, you can use: local for small tasks OSS cloud for normal coding work premium only when it actually matters It also tracks: actual cloud spend which route was used fallback events tokens safely removed estimated savings vs premium models The goal is simple: stop wasting premium tokens on cheap tasks. First launch is small: small task → local normal task → cheaper cloud hard task → premium provider fails → fallback duplicate code → safely removed receipts → clear spend trail AI coding is only going to get more expensive if every agent step goes to the top model. Badgr Auto is my attempt to make AI coding cheaper without making it worse.

Launched at Build, Microsoft Scout is a new AI assistant meant to bring the power and flexibility of OpenClaw into the Microsoft 365 system.