Why ZFS is perfect for agent workloads Hive, a platform for running persistent coding agents, uses ZFS as the storage layer for its agent lifecycle because a single dataset object handles snapshots, clones, holds, quotas, sends and delegated permissions, letting the platform fork an isolated writable session from a trusted base with two commands: `zfs snapshot base@verified` and `zfs clone -o readonly=off base@verified sessions/`. Hive said ZFS's copy-on-write tree, in which every block pointer carries a checksum and the first write to a cloned block forks only that block, makes isolation structural rather than a permission bit, and that incremental send emits only changed blocks, compressed. Hive also noted the trade-off: the ARC is a global cache with no per-agent partitioning, and operators on a hypervisor host must cap it themselves. Why ZFS is perfect for agent workloads We build Hive, a platform where teams run persistent coding agents. Storage turned out to be one of its hardest problems, and ZFS ended up one of its key components — not a filesystem we happened to have, but the layer the whole agent lifecycle stands on. Agents need three things from storage: fork an isolated, writable environment from a trusted base in constant time; checkpoint and rewind it constantly; and prove what changed. Most platforms assemble these from separate parts — an overlay here, a snapshot daemon there, a diff format bolted on top. ZFS has all three, and the reason is architectural. They are one design, not a feature list. The dataset is the unit of administration Every operation an agent platform needs — snapshot, clone, hold, quota, send, delegated permission — addresses the same object: the dataset. That is what makes the lifecycle composable. A session is a dataset. A checkpoint is a snapshot of that dataset. A fork is a clone of that snapshot. Replication is a send of that snapshot, resumable after interruption. Accounting is the usedby property family of the same dataset, attributing allocated space per tenant — accurate to the block, with the usual caveats that block-size rounding and compression mean charges never map one-to-one to bytes written. Nothing to integrate, because nothing was ever separate. Copy-on-write is the mechanism ZFS is a copy-on-write tree. Every block pointer carries a checksum; writes never overwrite in place; a snapshot is a pinned tree root. A clone is a new dataset whose root references the snapshot's tree, and the first write to any block forks only that block — so isolation is structural rather than a permission bit, and destroying a session frees exactly its blocks. Forking a session is two commands: zfs snapshot base@verified zfs clone -o readonly=off base@verified sessions/