Cloudflare's 100KB Git: The Agent Economy Gets a Landlord

One hundred kilobytes. That is what is left of Git after Cloudflare's engineers finished with it — a full server-side implementation, rewritten in Zig, compiled to WebAssembly, and dropped onto the edge like a stone into still water. The blog announcing it carries a date I cannot independently verify, 2026-04-16, which should tell you something about the epistemic ground we are all standing on. But the technical artifact is real enough to argue with. And what Cloudflare calls "Artifacts" — a versioned file system built specifically for AI agents — is not really about storage. It is about who gets to be the landlord of the machine economy. Tracing the code back to its chaotic genesis, you find the same move every hyperscaler makes: take an open protocol, wrap it in proprietary services, and sell the convenience back to the people who built the commons. Git survived two decades as the closest thing our industry has to a public utility — a protocol so boring and so universal that we forgot it was political. Artifacts wants to be the toll booth on that road. Here is what we actually know, stripped of the marketing varnish. Cloudflare Artifacts is a Git-compatible object store where autonomous agents can checkpoint their state, branch, fork, and roll back. The stack is specific and — I will give them this — technically coherent. Durable Objects provide strongly consistent, single-threaded actor storage. Queues handle the event-driven glue. Workers Builds replace external CI, collapsing version control and deployment into one latency-optimized loop. And the centerpiece: a Git server reimplemented in Zig, targeting roughly 100KB of WASM, running directly on Workers at the edge. The pricing is Cloudflare's signature penetration play. Fifteen cents per thousand operations, with the first ten thousand free each month. Fifty cents per GB-month for storage, first gigabyte free. A mandatory Workers Paid plan at five dollars a month, which is the tell — Artifacts is not a product, it is an attachment. It exists to drag more usage through Durable Objects, Queues, and the Workers runtime, raising platform revenue per account without paying to acquire a single new customer. There is also namespace-level data residency, US and EU regions, which is not aimed at hobbyist agent builders. It is aimed squarely at regulated industries — finance, healthcare, government — that cannot put their state on GitHub and cannot explain to an auditor why their agent's memory lives in a shared multi-tenant store. That is a real differentiation, and it is the quietest and most commercially serious thing in the announcement. The single most interesting design decision is not the WASM at all. It is that fork becomes a first-class primitive. In the human Git world, a fork is a social event — a political rupture, a schism, a new project with its own governance and its own mailing list. In the agent world, a fork is a checkpoint. A cheap experiment. An undo button. Cloudflare has quietly redefined the oldest verb in open source into something an autonomous process can fire thousands of times an hour without a second thought. Let me be precise about where the innovation actually lives, because the press framing blurs three different claims into one convenient haze. First, the stack is not novel. Durable Objects, Workers, Queues — these are existing Cloudflare primitives composed together. Anyone who has shipped on this platform for more than a quarter recognizes the shape immediately. There is no new consensus algorithm here, no new execution model, no new trust primitive. Where logic meets the absurdity of market hype, you get headlines about "the first version control built for agents" — a claim that is unfalsifiable, and therefore worthless as evidence. Second, the Git-in-WASM work is genuinely impressive as engineering, and I want to be fair to it. Compressing a mature C codebase down to 100KB of WASM is not a weekend project. It requires ruthless protocol subsetting, deterministic memory discipline, and a willingness to abandon features the Git project spent fifteen years accumulating. My read, from having audited more infrastructure than I care to admit, is that this implements the smart-HTTP transport core — upload-pack and receive-pack — and very likely not the full semantic surface. Merge, rebase, submodules, hooks, and LFS are almost certainly absent or partial. For human developers that would be disqualifying. For agents generating checkpoints, embeddings, and logs, the missing piece that matters most is large binary handling, and nobody has explained how a 2.5GB repository hydrates on demand without a data plane the size of a small country. Third — and this is the actual product — the fork primitive. This is where Artifacts stops being "Git on the edge" and becomes something worth arguing about. An autonomous agent's failure mode is not a merge conflict. It is a bad decision made at step forty-seven that poisons everything downstream. The ability to fork the entire state, run a parallel trajectory, evaluate the outcome, and discard the branch if it fails is not a convenience — it is a safety mechanism. It is the same instinct that makes on-chain execution so expensive and, to its believers, so valuable: every state transition is a checkpoint you can audit, and every rollback is provable. And here is where the decentralized lens earns its keep. What Artifacts proposes for agents is, structurally, what blockchains have offered for a decade. Deterministic state, cheap branching, verifiable history, rollback as a first-class operation. The difference is that Cloudflare is doing it inside a permissioned platform with a single controlling authority, and calling it infrastructure rather than custody. In the silence between the block hashes, the whole argument over who owns the state layer is being settled by pricing pages rather than by consensus. The open-source boundary confirms the intent with almost surgical precision. ArtifactFS, the client driver, is open — and pointedly designed to work against any Git remote, so it carries standalone value independent of the platform. The server, where the lock-in actually lives, is closed. That is textbook open-core: Red Hat's model replayed for the AI era. You get the developer mindshare; Cloudflare keeps the moat. I have watched this pattern since the first enterprise "open" platforms of the 2000s, and it always ends the same way — the commons becomes the loss leader, and the paid tier becomes the only place where the interesting problems get solved. The narrative everyone will repeat is that GitHub is the incumbent to beat. I think that framing is backwards, and it flatters Cloudflare. GitHub does not need to build an agent-native VCS. It needs to keep the agents where they already are, which is on GitHub. Microsoft has Copilot, Actions, Codespaces, and a network effect measured in hundreds of millions of developers. Cloudflare's differentiation — edge deployment, strong consistency, aggressive pricing — is real but narrow, and it competes on the axis where GitHub is weakest rather than the axis where it is strongest. The "missing piece of the agent stack" language is not analysis, either. It is Cloudflare's own marketing, repeated by a news source so mismatched to the topic that a blockchain outlet is running a developer-tool press release nearly verbatim. That tells you about the information supply chain, not the product. The deeper blind spot is that Artifacts may be solving a problem agents do not have yet. Most agent frameworks do not need a specialized VCS. They need reliable state, and a versioned filesystem gets them ninety percent of the way. Cloudflare is betting that scale will force specialization. That bet only pays if agents become truly autonomous and truly numerous — and if that happens, the cost model becomes the whole story. Every Durable Object is a single-threaded actor, so a hot repository is a throughput bottleneck, and horizontal scale means sharding, which means cross-shard coordination, which means cost rising non-linearly with concurrency. Fifteen cents per thousand operations looks generous until a single autonomous task burns ten thousand operations in an afternoon. An evangelist who doubts his own gospel should say it plainly: the decentralization argument does not win by moral force. It wins when the centralized option becomes too expensive or too brittle to trust. Cloudflare just handed us the benchmark to measure against. Watch the free tier and the GA date, not the launch blog. If agents are real, ten thousand operations a month will evaporate in days, and the pricing will climb the way every Cloudflare beta price has climbed before. The fork primitive is the one idea genuinely worth stealing — and worth rebuilding in the open, where no single landlord decides what an agent is permitted to remember.