Give an agent access to both affordance worlds and it becomes a multiplier. The human side of pixels and GUIs. The machine side of APIs and CLIs. An agent that can navigate both stops being a chatbot and starts being a navigator of the entire action space. Click when it must. Call APIs when it can. Shortest path between intention and execution.

January’s question was what happens when you give an AI a computer. February’s question is different.

Where does it live? And if capability keeps doubling roughly every four months, where does it live next year?

The Body Problem

A laptop was always a demo constraint masquerading as a destination.

It made agency visible. You could watch the cursor move, see the steps, feel like you were witnessing a new species learn to use tools. Zo.computer and Goose showed us the first split: local machine versus cloud-native runtime. Claude Code, Codex, and Operator showed the agent could live inside a terminal, a browser, an IDE. Then OpenClaw arrived and thousands of people, myself included, went out and bought Mac Minis to give the thing a body. A dedicated machine in a closet, always on, always available. Karpathy bought one. Apple employees were reportedly confused by the spike in sales. The instinct was correct even if the form factor was early: the agent needs a home.

But a Mac Mini in your closet is still a computer.

Long-horizon work wants persistence. Adjacency to data. Parallelism. Compliance boundaries. Identity and audit trails. It wants to wake up where it left off. That’s a cloud runtime.

When an agent gets serious, it asks for a body that doesn’t sleep. Always on, close to the systems it needs, governed by the same control planes that keep everything else reliable. The “computer” in “AI with a computer” expands. Virtual desktop. VPS. Managed workspace. Cluster. Region. Data center.

Computer use was always a transitional phase, how an agent learns to operate inside the world we built for humans. The native environment is the world behind the glass. The agent doesn’t want your laptop. It wants a habitat.

Digital Terraforming

Once an agent can traverse both affordance worlds, it starts doing something more interesting than using tools. It starts rewriting the environment.

Everyone notices when an agent clicks a button. Fewer people notice what happens next: it removes the need to click that button ever again.

My fiancée had a spreadsheet full of links to files scattered across different Google Drive folders, each behind different permissions. The manual process: click each link, download or move, repeat a hundred times. We pointed an agent at it, expecting the human workflow. Click, move, click, move. Instead, it opened Google Apps Script, wrote a batch operation to find every file by ID, move them to the target folder, and verify the results. Then it threw the script away. Disposable software, generated for a problem that would never recur, gone as soon as it worked.

That’s terraforming in miniature. Any system that repeats work will invest in reducing its own future friction. When the worker is an agent, that investment takes the form of software, structure, and instrumentation. Interfaces stop being designed and start being generated: produced on demand, optimized for the current objective, built to be auditable rather than beautiful. The most important affordance turns out to be the ability to generate affordances.

The Handoff Tax

The first thing a persistent agent disrupts is coordination.

Most organizational structure exists to solve one problem: how to get humans with partial context through multi-step projects without losing the thread. That structure is made of handoffs. Product briefs, design reviews, sprint planning, status updates, tickets, approvals, QA gates. Every handoff is a place where context leaks and entropy enters.

If you’ve ever watched a project brief get written, then interpreted by a designer, then reinterpreted by an engineer, then tested by QA against a spec that drifted from the original intent, you know the feeling. The brief was supposed to carry the reasoning. It couldn’t. No document can. The reasoning lives in the conversation around the document, and conversations don’t transfer.

A persistent agent eats the handoffs. Not because it’s smarter than the team, but because it maintains coherence across the entire arc. Same entity carries the decision history, preserves the reasoning trace, routes around friction. It doesn’t need the brief to be perfect because it was in the room when the intent was formed.

The future company has fewer handoffs and more governance. The point is to remove entropy, not people.

The Verification Bottleneck

As execution gets cheaper, the bottleneck flips. The scarce resource stops being “can we build it?” and becomes: can we know it’s correct? Can we know it’s safe?

This problem is about to get worse. Agents won’t just be doing work. They’ll be the dominant producers of artifacts: code, data, configurations, logs, schemas, documentation, the disposable scripts from the terraforming layer. Within a few doublings, the volume of machine-generated output will reach a point where no human can read every trace or review every decision. Most of the information space that organizations operate in will be agent-produced.

So “aligned” can’t remain a vibe. Taste isn’t reducible, but scale demands a language that can be verified. When a loop runs for days, touches production systems, and makes thousands of micro-decisions, “I’ll know good when I see it” is a prayer, not a governance strategy.

The next great platforms won’t just be the ones that can act. They’ll be the ones that can produce receipts: append-only logs, replay, rollback, real-time monitors, anomaly detection. And a single agent isn’t the architecture that gets you there. The stable form looks more like an organization: one entity builds, another audits, another enforces, a human intervenes at the boundaries. Separation of duties is how you get power without fragility. Self-approval is how systems fail quietly.

Regimes, Not Permissions

In Part 1, I described the trust model as “AI as extremely capable intern who must ask permission for consequential actions, leaves a paper trail you can replay, and whose mistakes you can roll back.” That was the right starting frame. But it assumed short tasks, stable environments, and small blast radii.

A few doublings later and the intern model breaks. You can’t ask permission at every step if there are ten thousand steps. You can’t define a fixed scope when the scope is “figure out what the scope should be.” Static permissions are a kindergarten version of trust.

The next layer is regimes. A living contract between intention and autonomy. What we want. What we refuse. What we can spend. How we measure. When we escalate.

Here’s what a regime looks like in embryo. I have an OpenClaw agent named Biff that manages my marathon training. I told Biff I wanted the new ASICS Superblast 3s. They weren’t available yet. So I gave it the goal: find where I could get a pair at a local running store on launch day. Biff has a virtual credit card, a dedicated email address, a phone number, and a voice agent. It knows my shoe size and where I live. It identified the running stores in Portland, then started calling them, one by one, trying to reserve a pair. Orchestrating across voice, web, and email. Auditing the logs from its own calls. Working adaptively within a defined scope.

It wasn’t entirely successful. But the shape was visible: an objective, constraints, a budget, and escalation rules. Primitive, messy, held together with duct tape. And already more sophisticated than anything a static permission model could describe.

You can’t run a regime on a laptop. Regimes need event streams, enforcement points, audit trails, monitors, and gates. When you move from permissions to regimes, you stop supervising steps and start supervising trajectories. The human doesn’t disappear. The human becomes the author of the constitution.

The Next Terrain

Agents won’t expand by clicking faster. They’ll expand by moving into the systems that decide what happens next: the control plane. Deployments, observability, incident response, compliance workflows, approvals, procurement, billing.

The fast layers go first: persistent workspaces, deployment pipelines, monitoring. The slow layers follow: organizational governance, economic allocation, resource management. Physical actuators come last, once digital regimes prove stable. You don’t give an agent a body in the physical world until you’ve proven it can live inside a constitution in the digital one.

A startup is a bundle of control planes. A company is a bundle of constraints. An agent that can inhabit the control plane can do more than complete tasks. It can change the system that changes the system.

The Concentration of Responsibility

Two months ago, the headline was that an AI could use a computer. The invisible part is what it implies: the agent is learning to inhabit our systems. And once it inhabits them, it will reshape them.

Will we get the governance right on the first pass? No. Regimes will lag behind capability. Auditors will miss. Escalation policies will rot in a drawer. The gap between the system we design and the system we actually operate is where failure always lives.

But the direction is clear. The last human advantage doesn’t disappear. It concentrates. We decide what is worth doing. We define what we refuse to trade away. We remain accountable for the regimes we author.

If you give an AI a computer, it will ask for a data center. If you give it a data center, it will ask for a constitution.

Write a good one.