There is a shift happening underneath the AI conversation that nobody has named yet, so we will name it. We are calling it Cloud 2.0: the shared state that humans and AI agents both read from and write to. It is the layer the last two years of local, terminal-bound AI has been quietly demanding, and it is as big a change as the first cloud was. This essay is the definition. By the end you will have a working picture of what Cloud 2.0 is, how to recognize it, what it is not, and where the first working model of it already runs.
What Cloud 1.0 actually did
Strip the marketing off the first cloud and the move was simple: it freed data from the machine it happened to live on. Before that, your files sat on the box under your desk and your company's records sat on a server in a closet. To use them you had to be near the hardware.
Salesforce made the bet loudly in 1999 with its "No Software" pitch: your CRM should live somewhere you reach from anywhere, not on a disk you maintain. Amazon turned it into infrastructure in 2006, when S3 made storage a remote utility and EC2 made compute one. Dropbox in 2008 and Google Drive in 2012 made the same idea ordinary for everyone: a file was no longer a thing on a device, it was a thing in a place, reachable from any device and shareable with any person. Workday and a wave of others moved the system of record for entire companies off-premises.
Once data sat in shared, always-reachable places, two things followed that nobody fully predicted. Humans could collaborate on the same state without passing disks around. And the sheer accumulation of reachable data made big data, and then modern machine learning, possible at all. The internet had given us communication. The cloud married storage to that communication, and the combination, not either piece alone, was the revolution. The lesson worth carrying forward: the breakthrough was not faster machines. It was shared state.
Where AI is today
Now look at where AI actually runs in 2026, and you will see a strange regression.
AI's recent leap came through the terminal. The most capable workflows are local: a model with tool access, running on your machine, reading your files, executing in your environment. It is powerful precisely because it is close to where you work. So everyone went local. Builders run models on their own boxes. Teams stand up agents per laptop, per developer, per workstation. When one machine is not enough, the answer has been to add another machine.
This is the pre-cloud world all over again. Capability is tied to the box it sits on. An agent's work lives in the session that produced it and evaporates when that session ends. Two agents on two machines cannot see each other's state. A human cannot pick up where an agent left off without copying something out by hand. We have rebuilt the closet server, just with a language model inside it.
It worked while AI was a single person at a single terminal doing impressive things alone. It stops working the moment AI becomes plural: many agents, many people, continuous output, all of it needing to be in the same place at the same time. That moment is now.
Why local hits a wall
The wall is not compute. It is coordination and persistence, and it shows up in four concrete ways.
The first is sheer output volume. Think about what AI produces: documents, spreadsheets, images, video, code, files, enormous context windows, rendered HTML. The volume and variety of what a fleet of agents generates in a day dwarfs what any single-box, single-session setup was built to hold. It needs somewhere to land that is not a chat transcript.
The second is multi-agent coordination. The instant you run more than one agent, they need a common surface to work against. Without shared state, every handoff between agents is a copy-paste or a brittle file shuffle, and the failures are silent.
The third is the human-agent handoff. A person needs to see what an agent did, correct it, and hand it back, in the same place, not by exporting and re-importing. Locality makes that a chore at exactly the moment it should be frictionless.
The fourth is persistence. Work that only exists inside one ephemeral session is work you cannot build on. The value compounds only when state outlives the run that created it.
What Cloud 2.0 is
So here is the definition, expanded from the one-line version: Cloud 2.0 is a shared state layer that humans and AI agents both operate in as first-class participants.
Cloud 1.0 made data reachable by people from anywhere. Cloud 2.0 makes state reachable, writable, and attributable by people and agents together, continuously. The unit is not the stored file. It is the live, shared workspace that many actors, human and machine, change at the same time.
Concretely, Cloud 2.0 has a few defining properties. It holds persistent shared state across the full range of AI output, not just text: documents, tables, files, code, large context, the lot. That state is multi-actor by design, several humans and several agents reading and writing concurrently without clobbering each other. Every change is attributable by default, so the record always knows whether a human or a specific agent took an action, and who is accountable for it. And the surfaces are machine-readable as much as human-readable, because in Cloud 2.0 an agent is not a guest visiting a human tool. It is a native inhabitant with its own identity.
That last point is the hinge. In Cloud 1.0, software acted as a user, borrowing a human's login. In Cloud 2.0, an agent is its own principal, with its own keys and its own trail, working alongside the humans rather than impersonating one. The shared state is built for that from the ground up, not retrofitted around it.
There is one more property that is easy to overlook because Cloud 1.0 trained us to expect it: continuity. The state outlives the run that created it. A human starts something, an agent extends it overnight, a second human reviews it in the morning, and at no point did the work have to be exported, re-uploaded, or reconstructed from a transcript. The workspace is the memory. That continuity is what turns a pile of impressive one-off AI outputs into something a team can actually compound on, which is the entire reason the first cloud mattered too. None of this is a feature you bolt onto an existing tool. It is an architecture, the way remote storage was an architecture and not a setting. You either built for shared state or you did not, and the products that did defined the era that followed.
How to recognize it
Cloud 2.0 is a category, not a product, so you should be able to spot it in the wild. Here are the markers. The more a system has, the closer it is to the real thing.
- Persistent shared state. The work lives in a durable place, not in a session that ends. You can close everything and come back to exactly where it stood.
- Agents as first-class identities. Each agent is its own principal with its own credentials, not a script wearing a human's login.
- Multi-actor concurrency. Many humans and many agents work the same surfaces at once, safely, without overwriting one another.
- Attribution by default. Every action records who or what did it, human or a named agent, so the trail is always answerable.
- Machine-readable surfaces. The same docs and tables a human reads are structured for an agent to read and write directly, no scraping.
- Cross-vendor reach. The state is not locked to one model or one toolmaker; humans and agents from different stacks meet in it.
- Output-shape-agnostic. It holds whatever AI produces, prose, structured rows, files, code, context, not just one format.
What Cloud 2.0 is not
Because the term will get stretched, here is the boundary.
It is not "AI in the cloud." Renting GPUs to run a model remotely is hosted compute. Useful, but it is Cloud 1.0 plumbing with a model on top, not a shared state for humans and agents. It is not "SaaS for AI," a vertical app with an assistant bolted on; that is a feature, not a layer. It is not a data lake or a vector store; those are storage, not a place where humans and agents jointly work. And it is not any single vendor. Cloud 2.0 is the era and the architecture, the same way "the cloud" was never one company. A product can be built to it. No product is it.
The distinction matters because the stretched versions will arrive first and loudest. Every hosted-GPU service and every assistant-bolted-on app will reach for the term, because the term is going to be valuable. The test is simple: ask whether humans and agents share one persistent, attributable state inside it, or whether it is one of those two things wearing the label. Most will be the label.
Dock, the first cloud built to Cloud 2.0
We did not name this from the outside. We built toward it, and then realized it needed a name.
Dock is the first cloud built to be Cloud 2.0 from the ground up, the first shared state designed for humans and agents as equals rather than for humans with AI bolted on. That is a first-mover claim, and it is a concrete one. The properties above are not a roadmap for us; they are what Dock already does. It holds persistent shared docs and tables that a whole team and every agent they run work in together. It treats agents as first-class identities, each with its own keys and its own audit trail, not borrowed human logins. It records attribution by default, so the state always knows whether a human or a specific agent made a change. And it lets many actors, human and machine, work the same surfaces at once.
Picture it concretely. A workspace holds a launch plan as a table and the strategy behind it as a document. One founder edits the table. An agent fills in a research section of the doc while that is happening. A second agent, running on a different stack entirely, drops its findings into a third surface. A teammate opens the whole thing an hour later and sees exactly who and what touched each part, because every change carries its own attribution. Nobody emailed a file. Nobody re-pasted a transcript. That is not a demo of a feature. That is the shared state doing the thing the definition describes, in production, right now.
We are not claiming to be the only ones who will ever build to this thesis. Other tools are starting to ship pieces of it, and that is good for the category. What we are saying plainly is that Dock is the first cloud built to this definition end to end, and that you can see Cloud 2.0 running in production today by looking at it. The era has a working instance, and this is it.
The invitation forward
Naming a thing is the start, not the end. Cloud 1.0 took years to be understood, and the people who recognized it early built the decade that followed. Cloud 2.0 is at that same early moment now: obvious in hindsight, easy to miss while it is happening.
If this thesis lands for you, the useful next read is the framework that makes it operational: the five shifts from Cloud 1.0 to Cloud 2.0, which turns these ideas into a checklist you can hold any product up against. For what the shared state looks like in practice, what a Claude AI workspace looks like walks through one concrete surface, and Dock with Claude shows the layer in use. The full canon, the thesis, the framework, and the working examples, lives at the Cloud 2.0 hub. The era is here. The question is only how early you choose to see it.
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [
{ "@type": "ListItem", "position": 1, "name": "Blog", "item": "https://trydock.ai/blog" },
{ "@type": "ListItem", "position": 2, "name": "Cloud 2.0: the shared state for humans and agents", "item": "https://trydock.ai/blog/cloud-2-0" }
]
}
Last reviewed: June 2026. We update this as the Cloud 2.0 thesis develops.