Two announcements landed in the same week. They solve overlapping problems. They reveal completely different beliefs about what's happening.
On April 7, Amazon launched S3 Files: a POSIX filesystem view layered on top of S3. The pitch is practical — your AI agents can now grep and cat and sed directly against object storage, no sync pipelines or SDK wrappers needed. Data never leaves S3. Standard Unix commands just work.
On April 16, Cloudflare launched Artifacts: a Git-native versioned filesystem built from scratch for agents. Create millions of repos programmatically. Fork sessions. Time-travel through state. Built on Durable Objects and a custom Git server written in Zig, compiled to a ~100KB WASM binary. The pitch isn't "your existing tools work" — it's "agents need tools that don't exist yet."
Neither is wrong. But the gap between them tells you something about where infrastructure is headed.
#The Retrofit
S3 Files solves a real problem. The object-vs-file impedance mismatch has tortured engineers for twenty years. You can't tail -f an S3 object. You can't run pandas.read_csv() against a bucket without downloading the file first. The workarounds — data duplication, sync pipelines, SDK wrappers — all carry operational overhead that compounds at scale.
Amazon's solution is elegant engineering: EFS under the hood, bidirectional sync, intelligent caching (files under 128KB get pulled into fast storage, larger files stream from S3). NFS v4.1, POSIX permissions stored as S3 metadata, TLS 1.3 in transit. It works with existing buckets. No migration required.
The agent narrative gets bolted on afterward. "Agents use file-based tools natively." "Multi-agent pipelines need shared mutable state." True statements, both. But the product wasn't designed for agents. It was designed to solve a pre-existing pain point that agents happen to also feel.
This is the retrofit pattern: take something that works, make it accessible to a new consumer. The world doesn't change. The adapter does.
#The New Bet
Cloudflare's Artifacts starts from a different premise: agents don't just need access to files. They need versioned, forkable, disposable state.
The design decisions reveal the thinking. Every agent session gets its own repo — not a shared filesystem, an isolated workspace with full history. Fork from any point. Roll back. Diff. Share a session by sending a URL. Pick up someone else's work by forking their state. The Git protocol was chosen not because agents need source control, but because Git's data model — commits, branches, diffs, merges — maps onto how agent work actually flows: iterative, branchable, reversible.
Internally, Cloudflare uses Artifacts to persist sandbox state and session history in per-session repos. The filesystem and the conversation travel together. Fork a debugging session to hand it to a colleague. Time-travel through both the code and the prompts that produced it.
This is the new-bet pattern: observe how agents actually work, then build primitives that match the grain. The world changes. The infrastructure follows.
#The Split Is Everywhere
Storage is just where it's most visible. The same fork runs through the whole stack.
Compute. AWS Lambda was built for short-lived, stateless functions — the opposite of agent sessions, which are long-running, stateful, and non-deterministic. AWS knows this. Their own documentation for Bedrock AgentCore concedes the point: existing primitives "were never designed for the peculiar demands of AI agents." AgentCore bolts agent-aware orchestration on top of Lambda and Fargate. Meanwhile, Cloudflare's Agents SDK and container-per-session model builds compute that's agent-shaped from the start — Durable Objects that persist state across requests, hibernation that lets agents sleep and wake without losing context.
Protocols. MCP (Model Context Protocol) is the most interesting case because it lived the retrofit-to-new-bet arc in real time. When it launched in November 2024, remote communication used HTTP + SSE — two existing web standards duct-taped together. One endpoint to send requests, a separate persistent SSE connection to receive responses. It worked, but it was fragile: connection drops during long operations lost responses, scaling persistent connections was painful, correlating across two endpoints added complexity. Within five months, the MCP team deprecated SSE and shipped Streamable HTTP — a new transport they invented. Single endpoint. Dynamically upgrades from simple request/response to streaming when the interaction needs it. Server can push back to the client on the same connection. Built on HTTP under the hood, but the abstraction is genuinely new. They tried the retrofit. It wasn't enough. Meanwhile, A2A (Agent-to-Agent) skipped straight to the new bet — a protocol for peer relationships between agents, with discovery, negotiation, and task delegation built in from day one.
Auth. OAuth was built for humans clicking "Allow" in a browser. The retrofit: make agents go through the same flow with headless browsers or token exchange hacks. The new bet: agent-native identity — API keys, capability tokens, scoped permissions that don't assume a human in the loop. Cloudflare's Artifacts generates per-repo tokens programmatically. No browser. No consent screen. The auth model matches the consumer.
#What the Bet Reveals
The retrofit says: agents are a new kind of user. Give them access to what exists, and they'll figure it out. The value is compatibility — no migration, no new abstractions to learn, works with your existing stack.
The new bet says: agents are a new kind of computing. They need primitives designed for how they work — iterative, parallel, disposable, branchable. The value is leverage — when the infrastructure matches the workload, you get capabilities that retrofits can't reach.
Both positions have evidence. S3 Files will immediately help thousands of teams who have AI pipelines reading from S3 today. Artifacts won't help anyone until they rethink their architecture around per-session repos and forkable state. The retrofit has adoption. The bet has ceiling.
But the bets compound. Once you have versioned, forkable state per session, you can build things that a filesystem view can't support:
- Session replay. Walk through every state an agent produced, in order, with full context.
- Branching exploration. Let three agents try different approaches from the same starting point, then compare.
- Audit trails. Every mutation is a commit. Every commit has provenance. You don't need to build logging — it's the storage model.
- Collaborative handoff. Send a URL. The recipient gets the full workspace and the conversation that produced it.
These aren't features you add to a filesystem. They're properties of a different primitive.
#The Design Physics
I keep coming back to a frame from an earlier essay: constraints shape what's possible. The choice of storage primitive is a design decision about what agents can do.
A POSIX filesystem constrains agents to 1970s file semantics: linear, mutable, path-addressed. It works. It's familiar. But it encodes assumptions — files are edited in place, directories are hierarchies, there's one timeline — that don't match how agents actually operate.
A Git-native store constrains agents to versioned, content-addressed semantics: every state is a snapshot, every mutation is a commit, branching is free, merging is possible. It's less familiar. But the constraints enable capabilities that the filesystem model actively prevents.
This is the recurring lesson: the infrastructure you choose doesn't just serve your agents. It shapes what they can become.
S3 Files makes agents better at using existing tools. Artifacts makes agents capable of things they couldn't do before. That's not a quality judgment. It's a physics difference.
#Where It Goes
The honest answer: both patterns will coexist for a long time. Most teams will reach for the retrofit first — it's faster, cheaper, lower risk. The new bets will grow underneath, adopted by teams building agent-native products where the old primitives genuinely don't fit.
But I'd watch the Cloudflare pattern. Not because Cloudflare specifically will win — that's a business question, not an architecture question — but because the type of thinking they represent tends to compound. Every new primitive that matches how agents work becomes a building block for the next. Versioned state enables session replay enables collaborative debugging enables multi-agent branching. Each layer makes the next possible.
The retrofits don't compound the same way. They remove friction, which is valuable, but they don't open new design space. S3 Files means your agents can grep a bucket. That's useful today and exactly as useful in five years. Artifacts means your agents can fork reality. Where that leads is harder to predict — and that's exactly the point.
The fork in the stack isn't about storage. It's about what you believe agents are: smarter users of existing systems, or a new kind of computing that needs its own ground truth.
The bet you make shapes the world you build.