Last year, Manus was already giving agents a cloud execution environment. When OpenClaw took off in February, cloud providers were already helping people deploy it remotely. Over the past week or two, cloud agents have somehow become the new end state again.
The AI industry has a talent for rediscovering things that already exist.
The annoying part is that this time, it may have rediscovered the right thing.
Why the local-first AI agent wave appealed to me
The OpenClaw wave made local deployment look more technical, more independent, and frankly cooler.
An agent could keep running on your own machine while building up memory and a knowledge base. Owning the machine made it easier to retain control of what the agent accumulated. That was the real appeal of the local-first model for me.
OpenClaw still stores state on infrastructure the user controls. It can run on a personal machine, a cloud server, or a VPS. Local and remote deployment were already available choices.
So a long-running agent installed on a VPS does not become a new category just because someone calls it a cloud agent.
Installing OpenClaw on a VPS mostly gives the server a more expensive name.
The shift is the AI agent control plane
I reconsidered the cloud-agent argument because OpenAI, Manus, and Cloudflare are all moving in the same direction.
The immediate trigger for this discussion was a ChatGPT Work image posted on X by Codex lead Thibault Tibo Sottiaux. He described a product on your phone that can do work for you and keep going all day when needed. Tibo's original post contains that wording.
Cloudflare has already moved into actual product infrastructure. Its Long-running agents documentation covers persistent state and work that continues beyond a single request. Sandboxes provide isolated cloud execution environments. Manus gave tasks a cloud Sandbox from the beginning and later introduced an always-available Cloud Computer.
Several companies are placing the same bet. They see more usage data, engineering constraints, and user demand than the public discussion reveals. Their decisions are probably backed by stronger evidence than we can see from outside.
Here is the direction I now believe: the agent becomes an independent control plane. It dynamically routes each task across local and cloud execution environments, while scaling out workers when needed.
When a task needs local files or software, the control plane calls the local machine. When it needs continuous runtime, isolation, or more parallel capacity, it starts a cloud sandbox and adds workers. The execution environment can stop after the task finishes. The agent keeps the task and the routing relationship.
Older cloud deployment was mostly a one-to-one move. The agent left a local machine for a cloud server and stayed tied to that server. An independent agent control plane receives the task first, then chooses the environment. Its scale no longer matches the size of one machine.
Tibo's phone image makes more sense in that model. The user sends tasks and checks results from a phone. The control plane assigns the actual work to execution environments behind it. The task can continue after the user leaves the device.
This direction already has industry support. It also describes more accurately what several companies are building now.
Cloud scaling leaves state sovereignty unresolved
My initial discomfort came from mixing two different problems together.
The local OpenClaw wave addressed control over a long-running agent. The current cloud-agent wave advances orchestration across execution environments and the scale of agent workers. Both can be true at the same time.
An agent can operate as an independent control plane across local and cloud execution environments. Cloud capacity can expand, more workers can start, and tasks can continue running. The agent's persistent state still grows over time. Users need stronger control over that memory, knowledge base, and accumulated digital assets.
Execution environments can multiply and be replaced. Long-term assets should not become harder to control as the orchestration layer grows. The longer someone uses an agent, the more important this boundary becomes.
The local-first wave was not a mistake. It showed that a long-running agent accumulates things that belong to its user. The cloud direction has not returned us to last year's starting point either. It is solving orchestration, parallel work, and scale.
The cloud takes the compute scale. The unresolved question of control stays with the user.
An agent may call any machine. Long-term memory, knowledge, and digital assets still need to remain under better user control.