The web is quietly reverting to static files, but for a completely different reason than the last time.
For the past decade, the industry consensus has been that content must be dynamic. We built massive, complex server-side rendering (SSR) pipelines and hydration strategies because assembling a page on the fly was the only way to personalize it. The assumption was that the author creates a template, and the server computes the final output at read time.
When AI agents become the primary authors of web content, that assumption collapses. An agent does not need to fill in blanks in a shared template. It can simply generate a complete, bespoke HTML document, embedded with the exact CSS and JavaScript required for that specific user, and write it to disk in seconds.
When the marginal cost of a bespoke artifact drops to zero, the economics of dynamic rendering disappear. There is no longer a reason to compute at read time when you can generate a perfect artifact at write time.
This shift exposes a new set of infrastructure requirements: egress-free storage, edge-native delivery, stateful agent execution, and sandboxed compute. Most of the existing cloud stack was not designed to satisfy these constraints. The platforms that internalize this shift earliest will have a durable structural advantage in the agentic web.
Why Static Wins Again (But Differently)
Static files were originally abandoned because personalization required compute at read time. Agents invert that equation: personalization now happens at write time.
The result is a static file that is as personalized as any dynamically rendered page, but trivially cacheable, globally distributable, and entirely free of server-side compute at delivery.
We can see this playing out in production today. Our own product, Waldium, a multi-tenant site platform, recently underwent a radical architectural pivot to accommodate agent-driven content generation. Originally built on a standard SSR model, the platform encountered severe scaling friction as agents became the primary authors. A shared rendering surface inherently constrained what an agent could produce, and caching in a multi-tenant SSR environment proved notoriously difficult.
The solution was architectural: we removed the renderer entirely. Instead of rendering pages at request time, agents now produce finished HTML artifacts. These files are written through a Virtual File System (VFS) directly into an S3-compatible object storage bucket . The agent acts as the author, the CMS functions as the ledger, and the CDN serves as the delivery mechanism.
The artifact itself is the product.
The Write Path Is the Hard Part
When agents are the authors, the engineering complexity moves from the serving layer to the write path.
Agents iterate rapidly. An agent might rewrite a page layout ten times in a minute as it refines a design. If every iteration is written directly to a public storage bucket, users will see broken, intermediate states. Production platforms must implement an explicit two-phase artifact pipeline at the storage layer.
In Waldium, when an agent writes an HTML artifact, the platform routes the write to a private draft prefix in S3 (pages-draft/{filename}). This allows the agent to iteratively refine the document without exposing unfinished work . The public serving layer strictly reads from the published prefix (pages/{filename}). The act of "publishing" is no longer a rendering step; it is a pure storage promotion, executed via an S3 CopyObject operation .
Furthermore, agents require strict capability scoping. An agent must have tenant-scoped access to the filesystem, but it should not have ambient authority to overwrite any file on the platform. Waldium solves this by having a conductor service mint a short-lived JSON Web Token for every agent session, encoding the site ID and a strict expiry time. The VFS server validates this token on every request, enforcing tenant isolation at the filesystem level .
What the Serving Layer Actually Needs
Given that the artifact is static, what does the serving layer need to do? It needs to store millions of distinct, personalized artifacts and serve them globally with near-zero latency.
This changes the economics of hosting. Every artifact is a unique asset. On traditional hyperscale cloud providers, this model breaks down due to egress fees. If a platform stores millions of agent-generated HTML files in AWS S3 and serves them through CloudFront, the bandwidth costs scale linearly with traffic. The platform is penalized for its own success.
This is why edge-native, egress-free storage is becoming a prerequisite rather than an optimization. Cloudflare R2 provides S3-compatible object storage with zero egress fees . In an architecture where the volume of distinct static assets grows exponentially with agent activity, the ability to store an artifact once and serve it infinitely without bandwidth penalties is the only sustainable economic model.
When combined with an edge compute layer, the architecture collapses into a single tier. A Cloudflare Worker, running on a V8 isolate that spins up in milliseconds , can resolve a tenant from an incoming request, construct the R2 storage key deterministically, and stream the static artifact directly to the client. With a global network spanning over 330 cities and 500 Tbps of capacity , there is no round-trip to a centralized origin server. The edge becomes the origin.
The Agent Execution Layer
Serving artifacts is the output side. The input side is running the agents that produce them. This requires a fundamentally different compute model.
Agentic workloads are long-running, stateful, and bursty. An agent might spend ten minutes researching a topic, generating code, and validating an artifact. If the underlying compute instance crashes, the agent cannot simply restart from scratch. Traditional stateless compute models, like serverless functions that time out, or containers that charge full compute costs even when idle, are poorly suited to this.
The agentic web requires stateful compute primitives. The actor model, implemented in systems like Cloudflare's Durable Objects, provides exactly this. Each actor has its own persistent state, hibernates when not in use to consume zero compute, and wakes instantly when an event arrives.
This is the foundation of Cloudflare's Agents SDK. While orchestration frameworks define how an agent "thinks," the Agents SDK defines where it runs. It provides the execution layer, abstracting away the infrastructure to enable persistent, scalable execution . Because Durable Objects provide a stable, globally addressable identity, agents can persist memory across invocations, coordinate multi-agent workflows, and accept real-time WebSocket connections.
Also, agents require a safe environment to execute the code they generate. The naive approach of executing LLM-generated code in the same process as the agent is a severe security risk. The correct architectural pattern is capability-scoped execution: running the agent-generated code in a sandboxed isolate with zero ambient authority, where the developer must explicitly bind the capabilities the agent is allowed to access .
Conclusion: Infrastructure as the Moat
The AI infrastructure market is undergoing rapid commoditization at the model layer. As inference becomes a commodity, the competitive advantage shifts from model quality to infrastructure quality.
The companies building agent-driven content platforms today are discovering the same infrastructure requirements independently. They need egress-free object storage to make massive-scale artifact hosting economically viable. They need a global edge network to serve those artifacts with near-zero latency. They need stateful, sandboxed compute primitives to run the agents that author them. And they need a unified inference layer that provides automatic failover and streaming resilience for long-running processes.
The stack that satisfies all of these requirements in a single, integrated, economically coherent package will become the default substrate of the agentic web. The transition from dynamic rendering to agent-authored static artifacts is already underway, and the infrastructure providers that own the edge, the storage, and the execution environment will define the next iteration of the web.
