OK Computer
For sixty years, computing has worked in essentially the same way.
The computer offers capabilities, and you learn what's available. You then figure out how to invoke them in the right sequence to get what you want. Want expense reports from receipt photos? You find OCR software, learn how it works, extract the data, write formulas to structure outputs, and format the results. The computer can do all of this (the capability exists in the system) but you have to know what's possible, which tools to use, and how to orchestrate them into a working solution.
Supply-side computing means the machine says, \"Here are my functions. Compose them to achieve your goal.\"
Entire industries emerged around this model. UI and UX disciplines focused on making functions discoverable and learnable. Documentation teams explained what existed and how to use it. Training programs taught people the tools. Solution architects translated business intent into technical execution. None of this exists because computing is poorly designed. It exists because this is how the relationship between humans and computers has always worked.
The computer offered supply. You learned to use it. The translation burden fell entirely on you.
The Shift to Demand-Side
Several things shipped in the last few months. Together, they point to the same underlying change.
Research showed that when large models are given access to a computational environment, they spontaneously learn how to use it. File systems become memory-management tools. Scripts become execution mechanisms. External resources get pulled in when needed. No retraining is required; capability emerges once the environment is available and the model can explore what's possible.
Claude Code lets developers delegate whole tasks rather than individual keystrokes. Not \"help me think about this refactor,\" but \"refactor this codebase,\" while they go work on something else. The model plans the work, executes the changes, handles errors, and reports back when it's done.
Cowork applies the same pattern to non-technical users. You point it at a folder, describe what you want to accomplish, and watch it organize files, extract data from images, and generate reports. It's the same agent architecture, packaged for people who don't write code.
Other tools are doing similar work across workflow automation in different domains.
These aren't demos or research previews in the traditional sense. They're shipping products, running in production environments, used daily by thousands of people doing real work.
Together, they reflect a fundamental shift toward demand-driven computing. You express what you want to accomplish, and the system figures out how to deliver it. When you say \"organize these files by content,\" the agent determines which tools to use, in what sequence, and how to adapt when something doesn't work the first time. You don't need to know the supply exists. You express demand, and the system sources the appropriate supply to fulfill it.
How Utilities Actually Work
Real utilities follow a specific pattern, and it's worth being precise about it.
When you flip a light switch, you don't provision generation capacity. You don't route power through substations or balance load across the grid. You don't need to understand three-phase distribution, transformer ratios, or transmission-line capacity.
You express demand through the simplest possible interface (I want light) and everything else (generation, transmission, distribution, delivery) is handled by infrastructure you never see and don't need to understand. The interface is trivial. The orchestration is invisible. That's what makes it a utility rather than industrial infrastructure.
Cloud as Latent Supply
Cloud infrastructure gave us something unprecedented: elastic supply at massive scale.
Compute, storage, accelerators, databases, analytics services, AI capabilities (all globally distributed, available on demand, and scalable from zero to nearly infinite within minutes). The supply side became extraordinary, elastic in ways previous generations of infrastructure could never match, powerful enough to handle almost any computational workload, ready and waiting for demand.
But accessing that supply still required significant expertise. You needed to make architecture decisions about which services to use and how they should connect. You had to handle provisioning, manage orchestration across multiple services, and constantly optimize the tradeoff between cost and performance. The supply existed, and it was genuinely impressive in scope. What was missing was a demand-side interface that didn't require specialized knowledge to use.
The Workload Everyone Missed
Much of the infrastructure conversation over the last two years has focused on GPU buildouts.
Training clusters capable of handling trillion-parameter models. Inference capacity to serve millions of concurrent users. Power and cooling infrastructure to support extreme computational density. Data center expansion to house specialized hardware. The debate has centered on whether we're building enough capacity to support the next generation of foundation models and the applications built on top of them.
That demand is real, and the infrastructure requirements are substantial. But it isn't the whole story, and it may not even be the largest one.
Alongside training and inference, a different workload is emerging (one few people were explicitly planning for): general-purpose computing orchestrated by AI agents at scale.
Not training new models. Not serving conversational inference. Instead, running analyses that never ran before because setup costs were too high. Automating workflows that were too complex to justify with traditional approaches. Orchestrating millions of small, heterogeneous tasks across files, services, APIs, and systems (the kind of work that requires judgment about what to do next rather than executing a predefined sequence).
Agents turn out to be uniquely good at this kind of work. It's also exactly what cloud infrastructure was originally built to handle.
Over two decades, cloud providers invested heavily in elastic CPU capacity, distributed storage, networking infrastructure, managed databases, message queues, batch-processing systems, and sophisticated orchestration layers. These systems were designed to handle bursty, parallel, irregular workloads (the kinds of computational patterns humans were too slow and too expensive to fully utilize). The infrastructure was built for elasticity and variety, not just raw throughput.
While attention fixated on GPUs and the specialized infrastructure required for model development, the most immediate explosion in compute demand is landing on the general-purpose fabric that already exists. Agents don't just consume intelligence in the form of model inference. They consume infrastructure across the full range of cloud services, and they turn out to be remarkably good at keeping that infrastructure busy in ways humans never could.
The Interface Layer
The missing piece is now in place.
Local computer-use agents make the pattern clear. You express intent in natural language, the agent translates it into computational actions, and it delivers results. On a local machine, the supply side is necessarily finite (limited to what's installed, what hardware exists, what a single system can do).
Connect that same agent capability to cloud infrastructure, and something fundamental changes. Elastic supply meets trivial demand expression, and the constraints that shaped computing for sixty years begin to disappear.
You can say something like: \"Process these ten million customer records, identify purchasing patterns, generate personalized recommendations for each segment, and send them via email by tomorrow morning. Budget is $500, and accuracy matters more than speed.\"
The agent takes that specification and handles everything that follows. It determines what supply is required (databases, processing services, compute capacity, storage). It provisions the appropriate resources, orchestrates execution, parallelizes the work, scales up and down as needed, delivers the results in the requested format, and tears everything down when it's complete.
You never see the architecture that was built to fulfill your demand. You never provision resources or write orchestration code or choose specific services. You expressed demand with constraints, and the system sourced supply, orchestrated delivery, and optimized for your priorities.
Agent-defined architecture means infrastructure emerges from demand rather than constraining what's possible. Architecture becomes an implementation detail, the same way power generation becomes an implementation detail when you flip a light switch.
Utility Computing, Realized
Cloud providers built the foundation for this moment over many years. The elastic supply was always there, waiting for a way to make it genuinely accessible.
What changed is that the interface finally became trivial in the way utilities require.
Not: learn cloud architecture, understand service tradeoffs, provision resources, wire systems together, write orchestration logic, monitor performance, and continuously optimize.
Just: state what you want to accomplish, specify constraints around time, cost, and quality, and receive results that match your requirements.
The agent handles everything in between. Demand-driven computing at cloud scale means utility computing finally behaves like an actual utility. The interface is trivial. The orchestration is invisible. Computational capability is consumed the same way electricity is consumed.
Revealed Demand
The economic consequences become clear when you consider latent demand.
There is enormous latent demand for computation today (work that should happen but doesn't because translation costs make it uneconomical). Analysis that could provide genuine value but isn't worth the weeks required to learn tools and build systems. Automation that makes sense but would require expertise the organization doesn't have and can't easily acquire. Processing that remains manual because orchestration is too complex relative to the benefit.
All the \"I'd do this if I knew how\" work never gets done, not because it lacks value, but because the interface cost exceeds the expected return.
When the interface becomes trivial, latent demand becomes revealed demand. This isn't new desire appearing from nowhere. It's suppressed execution finally finding expression. The work always made sense. The computational capability always existed. What was missing was an economical way to connect intent to execution.
Agents amplify this effect further because they operate continuously. No context switching. No nights or weekends. No waiting for someone to have time to set things up. Demand can be expressed and executed at machine speed, twenty-four hours a day. Existing infrastructure gets used far more fully than human operation ever allowed.
We're not building dramatically more supply. We're finally accessing what already exists at the rate and intensity it was designed to handle.
What's Changing Now
The shift is already visible in production systems.
Developers are delegating meaningful work to agents they trust with real codebases. Non-technical users are orchestrating complex data transformations. Models are operating reliably inside computational environments, making consequential decisions about tool usage and resource allocation. The transition from assistant to operator is happening at scale.
Cowork was built by Claude Code in ten days (agents building the tools that democratize agents).
The implications cascade across multiple dimensions. For organizations, cycle time compresses dramatically. The path from idea to deployed solution shrinks from months to days or hours. Competitive advantage shifts away from \"who has the best architects\" toward \"who can articulate the clearest demands and constraints.\" The bottleneck moves from implementation to judgment.
For cloud providers, deep and broad service catalogs become true competitive moats. Elastic infrastructure finally sees sustained utilization across the full range of services.
For work, effort shifts from implementation toward direction. Less time figuring out how to make systems do things, more time deciding what's worth doing.
For the economics of computing, interface cost collapses. Organizations pay closer to the actual resources consumed rather than the blended cost of resources plus scarce expertise. Computation becomes unbundled from the cost of knowing how to compute.
Why This Happened Now
Three things converged.
Cloud platforms reached a level of maturity and reliability that made agent-defined architecture viable. Foundation models became capable of translating between human intent and computational supply with sufficient accuracy. Agent architectures crossed the reliability threshold required to delegate real work in production environments.
Each was necessary. None was sufficient alone. Together, they inverted the relationship between humans and computers.
Supply-side computing required humans to learn what machines could do. Demand-side computing requires machines to understand what humans want. That inversion has now occurred.
The Era Shift
For sixty years, you had to learn what your computer could do before you could make it useful. That constraint shaped software, teams, training, and entire industries. It was so fundamental that it faded into the background.
That constraint just ended.
Computers can now understand intent expressed in natural language, reason about available supply across vast service catalogs, orchestrate execution across distributed systems, and deliver results that match demand. The interface became trivial. The orchestration became invisible. Computing became a utility.
This isn't a future possibility. It's already happening, in production, at scale. Cloud providers built the supply over decades. Agent architectures built the interface in a matter of years. Revealed demand is about to meet elastic infrastructure in ways that will surprise anyone still focused exclusively on training and inference.
Everything accelerates from here.