But when I was about to ship a project the other day, I realized it still can’t replace me when it comes to DevOps:

1. Extremely high complexity: DevOps work is far more complex than programming. You’re operating command lines, logging into servers to check things, and you need to be incredibly careful — one mistake can have massive consequences.

2. Multi-dimensional interaction: You need to open various web UIs to manage cloud resources, copy-paste critical keys, deploy services, and operate cloud platform dashboards.

3. Constant context switching: You’re jumping between the terminal and web UIs, constantly verifying and handling edge cases. These operations go beyond what plain text can express.

While OpenClaw can already replace the programmer, no agent can truly handle DevOps yet. I think there’s a huge opportunity here. Maybe it’s time to build a real, autonomous DevOps Agent.

A Real Deployment Story

To show what DevOps difficulties actually look like, let me walk through my recent experience deploying Vocalflow — a voice input and transcription service I built.

First, I created a project on my self-hosted Dokploy instance and set up the app inside it. Then I manually clicked through the configuration to set the Docker image path pointing to GitHub’s container registry. Since the image is private, I had to dig up a GitHub PAT and paste it in.

Next, I wrote GitHub Actions for building the image — this was the one thing I had OpenClaw help with. Then I added another Action: once the image build completes, it calls the deployment platform’s API via curl to trigger auto-deployment. Since this step requires token authentication, I had to open the GitHub Actions settings page and add the Secret Value.

After all that, I pushed the code. The auto-deployment kicked in, but the app failed to start. I checked and found that better-sqlite3 couldn’t find its native Node extension. I had OpenClaw debug and search for a while:

1. First it tried switching the image base from Alpine to Debian Slim — didn’t help.
2. After several fruitless searches, I manually went to the project’s Issues and searched for “Alpine,” finally finding a relevant thread about Docker startup problems. https://github.com/WiseLibs/better-sqlite3/issues/146
3. In there I found a reply about pnpm workspaces — turns out pnpm was blocking better-sqlite3’s post-install build step, and you need to add an “approve-builds” config.

Once I told OpenClaw, it added the file and pushed again. The project finally came alive.

Then came domain configuration. I had to go to the Cloudflare Dashboard, find my top-level domain, add a subdomain, and point it to the deployment server. After that, I went back to Dokploy to map the new domain to the service and configure automatic HTTPS via Let’s Encrypt. I also needed to get the port right — I asked OpenClaw which port the service was actually running on. Only then was everything set up. I then checked Docker’s runtime logs to verify whether auto-migration ran correctly. It didn’t. I notified OpenClaw to look into it, but since it couldn’t directly access the production logs, verifying the fix was hard. I went back and forth debugging several times. Once that was sorted, I started a new session and had it research and write a CLI tool for fetching Dokploy service logs — just to make life easier next time. https://github.com/reorx/scripts/blob/master/dokploy-logs

The Future of the DevOps Agent

This is what DevOps work looks like — extremely tedious, fragmented, and unpredictable. There’s no universal approach to standardize it. Especially in the early stages of a project, entropy is incredibly high. Only after a project stabilizes can you start managing things through standardized text-based tools like Ansible or Terraform, forming SOPs.

In an era where development moves this fast and everyone is constantly building new projects, general-purpose Coding LLMs trained on existing data do have DevOps knowledge, but they can’t truly do the job. They can’t close the loop the way they can with development work. That’s the reality, and it’s the direction I believe future agents need to explore.

The core ideas behind such an agent:

• Not another DevOps platform: Don’t try to build yet another IaaS or ops platform.
• Adapt to the real world: The agent should adapt to real-world DevOps workflows, learning and mastering various skills — like operating AWS, Dokploy, or Cloudflare infrastructure.
• Pluggable architecture: The agent should be pluggable, like a person who can work at any company in any role. It can be installed into any system — whether that’s OpenClaw, Claude Code, or Cursor.

This would complete the last missing piece, freeing developers and small companies from DevOps busywork and closing the entire loop from idea → development → launch.

Sure, agentic coding tools like Claude Code and Cursor have made writing code easier, but at the end of the day, I was still the one writing. It might look like the AI is doing the work, but “writing” is a broad term—writing is execution. As the person making code happen, I’m the one writing code. Whether I’m editing line by line, copy-pasting, or telling an AI what I want and letting it finish—it’s still me “writing.” My role as the programmer responsible for turning code into reality hasn’t changed.

My productivity did improve, but for any given task, I still had to jump into the project, set up the environment, open my editor and Claude Code terminal. I was still the operator; the only difference was that instead of typing code manually, I was typing intent into a chat box. That only changed one dimension. Testing, debugging—most of it still fell on me. There was some change, sure, but it wasn’t mature, and there was no fundamental shift. I still had to stay deeply involved and monitor everything. And it was exactly this deep involvement that kept me stuck in the role of code executor.

Then OpenClaw came along, and everything changed.

I once discussed with my wife: in the age of AI, should you aim to be a “super individual” or build a “super team”? My answer is: become a “super manager.” A super individual who can juggle multiple threads and coordinate numerous AI tools is essentially demonstrating great management skills. Being a super individual means using AI tools to lift yourself from a basic executor to a higher-level one, and eventually into a manager. So even if you’re going the super individual route, you need solid management awareness and methods to keep everything running smoothly.

OpenClaw gave me the chance to become that super manager. After a few rounds of practice, I found that I could completely step away from the programming environment and handle an entire project’s development, testing, deployment, launch, and usage—all through chatting on my phone. That’s something Claude Code simply can’t do, or rather, it was never designed to.

As a general-purpose agent, OpenClaw interacts through messaging apps via voice, accurately understands what I mean, works independently for extended periods, and has solid memory—it can persist the methods and rules it picks up during work, gradually evolving through use. These are the capabilities that make it the real turning point for replacing me as the code executor. The biggest change is this: I just need to express my intent, and it automatically creates the project, writes up a plan for me to review. I can discuss changes with it by voice, and then it executes—even directing Claude Code to do the actual coding.

It replaced the “me” that used to write code, truly stepping into the programmer role and freeing me to act as a manager. A manager shouldn’t get bogged down in the specifics—they should focus on the higher-level, abstract work. That’s what management really is. You could even flip it around: you’re only a true manager when you can get things done purely through communication. Before, Claude Code alone couldn’t get you there. But when you have a dedicated machine running 24/7, set up with all your tools, and an agent that understands your intent sitting at the computer writing and debugging code for you—that’s when things truly change. That’s when the revolution arrives.

This is the biggest shift OpenClaw has brought—it completely transformed my workflow. Whether it’s personal or commercial projects, I can step back and look at things from a management perspective. It’s like having a programmer who’s always on standby, ready to hop into meetings, discuss ideas, take on tasks, report back, and adjust course at any time. It can even juggle multiple roles, like having several programmers working on different projects simultaneously. Meanwhile, I can be the tech lead keeping tabs on specific project progress, or the project manager steering the overall schedule and direction.

This has truly freed up my productivity, letting me pursue so many ideas I couldn’t move forward on before. I feel like my life genuinely changed at this moment. I used to have way too many ideas but no way to build them all on my own—they just kept piling up. But now, everything is different.

It’s like I suddenly have a team, achieving the dream scenario I always imagined: owning a company, hiring people to bring my ideas to life, while I just focus on product design and planning. I’m closer than ever to that dream state. Before, that required serious capital. Without money, you can’t hire anyone, and you can’t just be the idea person. Unless you’re some trust fund kid doing it for fun, you’re stuck bouncing between “indie developer who wants to build multiple projects” and “solo hustler just trying to survive.”

But now, I can finally break out of that trap and move toward actually having a team. It keeps all my projects moving forward at any time. It’s not perfect yet, but I’ve taken the first step.

Thank you, OpenClaw. Thank you, AGI—for me, it’s already here. The gears of fate are turning in directions I never imagined.