Undisk vs Fly.io Sprites: File vs VM Rollback

Undisk and Fly.io Sprites both address the problem of recovering from AI agent mistakes, but they operate at fundamentally different levels. Sprites checkpoints entire virtual machines. Undisk versions individual files. This difference in granularity shapes every aspect of the recovery experience.

The core tradeoff: Sprites gives you a full Linux environment with VM-level rollback. Undisk gives you a file workspace with surgical, per-file undo. Which you need depends on whether you need to restore environments or restore files.

What Fly.io Sprites Does

Fly.io Sprites provides persistent, stateful Linux microVMs built on Firecracker. Each Sprite is a full Linux environment with NVMe-backed ext4 storage (100GB+), an init system, and network access. Sprites can be checkpointed — their entire state (memory, filesystem, processes) is captured incrementally in approximately 300ms. Restoring a checkpoint brings the entire VM back to that exact state.

Sprites also support scale-to-zero. When a Sprite is idle, it hibernates and stops incurring compute charges. Resume from hibernation is fast, making Sprites cost-effective for intermittent workloads.

The key characteristic of Sprites’ recovery model is that it operates at the VM level. A checkpoint captures everything. A restore restores everything. There is no way to restore individual files, undo specific operations, or keep some changes while reverting others.

What Undisk Does

Undisk is a file workspace built for MCP-compatible AI agents. Every file operation creates an immutable, content-addressed version. Restoring a single file to any prior state takes under 50ms. Every mutation is logged with agent identity, timestamps, content hashes, and policy evaluation results.

Undisk does not provide a Linux environment, does not execute code, and does not manage VMs or containers. It is purpose-built for making file operations safe, reversible, and auditable.

Feature Comparison

The Granularity Problem

The fundamental difference between Undisk and Sprites is rollback granularity. This difference compounds across every aspect of the recovery experience.

Scenario: Agent Makes 20 File Changes, File 15 Is Wrong

With Sprites: You restore the most recent checkpoint before file 15 was written. This also rolls back files 16 through 20 — five good changes destroyed alongside the one bad one. If the checkpoint was taken before file 1, you lose all 20 files of progress. The agent must redo files 15 through 20 from scratch.

With Undisk: You call restore_version on file 15, specifying the version before the bad write. File 15 reverts to its prior state. Files 1 through 14 and files 16 through 20 are completely unaffected. Total recovery time: under 50ms. Total work lost: zero (except the bad write itself).

This is the difference between using Ctrl+Z on one document versus factory-resetting your entire computer. Both technically “undo” a mistake, but the collateral damage is vastly different.

Scenario: Agent Corrupts a Config File at 2 AM

With Sprites: You need to identify which checkpoint predates the corruption, restore the entire VM to that state, then manually re-apply any legitimate changes that happened after the checkpoint. If checkpoints are infrequent, the data loss window could be hours.

With Undisk: You call list_versions on the config file, identify the last good version by its timestamp and content hash, and restore it. No other file is affected. The agent can continue working immediately.

Where Undisk Leads

Surgical Recovery

Undisk’s per-file versioning means recovery is always surgical. You restore exactly what needs restoring and nothing else. Every file has its own independent version history, and restoring one file never affects another.

Sprites cannot achieve this. VM-level checkpoints are inherently all-or-nothing. The entire VM state — filesystem, processes, memory — is treated as a single unit. There is no mechanism to selectively restore parts of a checkpoint.

Structured Audit Trails

Undisk records every file operation with full metadata: agent identity, operation type, file path, content hash, timestamp, and policy evaluation result. These logs are append-only, content-addressed (tamper-evident), and retained per configurable policy.

Sprites provides no file-level audit trail. Checkpoints record VM state, but they do not track which files changed between checkpoints, what the changes contained, or which agent made them. For compliance, review, or debugging purposes, this information gap is significant.

Restore Performance

Undisk per-file restore completes in under 50ms. The operation looks up a version record in SQLite, retrieves the content (inline from SQLite for files under 128 KB, or from R2 for larger files), and writes it as a new version. The simplicity of restoring a single file versus reconstructing a full VM state explains the 6x performance advantage.

Sprites checkpoint restore takes approximately 300ms. This is fast for a full VM restore — impressive, even — but it is slower than Undisk’s file-level operation by a significant margin.

MCP Native

Undisk speaks MCP natively. Any MCP client — Claude, Cursor, Windsurf, or custom agents — can use Undisk’s file tools (write_file, read_file, list_versions, restore_version, get_diff) without special integration.

Sprites does not implement MCP. Integration requires building a bridge between MCP tool calls and Sprites’ REST API — additional code to write, test, and maintain.

Where Sprites Leads

Full Linux Environment

Sprites provides a complete Linux environment with NVMe-backed storage, an init system, network access, and support for arbitrary software. Agents can install packages, run services, execute complex build pipelines, and interact with databases.

Undisk is a file workspace only. It provides file CRUD operations (read, write, delete, list, search, move) with versioning, but it does not execute code or provide a Linux environment. If your agent needs to run code, Sprites gives it a full machine to work with.

Large Storage Capacity

Sprites offers 100GB+ of NVMe-backed ext4 storage per VM. For workloads involving large datasets, media files, or extensive build artifacts, this capacity is significant.

Undisk’s storage is backed by Cloudflare Durable Objects and R2, with per-file size limits (256 MB) and per-workspace storage quotas defined by tier. For most AI agent file workloads this is more than sufficient, but Sprites offers more raw capacity.

Process State Recovery

Sprites checkpoints capture not just the filesystem but the entire VM state — running processes, memory contents, network connections. Restoring a checkpoint brings the VM back to an exact running state, including all in-flight computations.

Undisk versions files only. It does not capture process state, memory, or any runtime context. If your recovery scenario requires restoring a running environment (not just files), Sprites is the right tool.

When to Use Both

The strongest architecture for production AI agents pairs Sprites for compute with Undisk for file persistence:

1. Agent runs inside a Sprite — full Linux environment with code execution capabilities
2. Agent stores files through Undisk — every write versioned, auditable, restorable
3. Bad file write happens — restore the file in Undisk in under 50ms, Sprite continues running
4. VM crashes or corrupts — Sprite checkpoint restores the environment; Undisk’s file versions are unaffected because they live outside the VM
5. Compliance review — Undisk provides the full audit trail of every file operation

This separation of concerns — compute in Sprites, storage in Undisk — eliminates the granularity problem entirely. You get full Linux capabilities from Sprites and surgical file recovery from Undisk.

The Bottom Line

Sprites and Undisk solve recovery at different levels. Sprites restores entire environments. Undisk restores individual files. The right choice depends on what you need to recover:

• Need to restore a running environment — choose Sprites
• Need to undo a single file change — choose Undisk
• Need both — run agents in Sprites, store files in Undisk

For AI agent file safety specifically — the ability to undo bad writes without losing other work — Undisk’s per-file versioning is the more precise tool. For full environment recovery including process state, Sprites’ VM checkpoints are unmatched.

Join the Waitlist

Frequently Asked Questions

Frequently Asked Questions

What is the difference between file-level and VM-level rollback?

File-level rollback (Undisk) restores a single file to a prior state without affecting anything else in the workspace. VM-level rollback (Sprites) restores the entire virtual machine — every file, every process, every change — to a previous checkpoint. File-level rollback is surgical; VM-level rollback is all-or-nothing.

Can Sprites restore just one file?

No. Sprites' checkpoint/restore operates at the VM level. When you restore a checkpoint, every file in the VM reverts to its state at checkpoint time. If an agent wrote 20 files and only file 15 was bad, restoring the checkpoint also rolls back files 16 through 20 — destroying all that progress.

Which is faster — Undisk restore or Sprites checkpoint restore?

Undisk per-file restore completes in under 50ms. Sprites VM checkpoint restore takes approximately 300ms. Both are fast, but Undisk is roughly 6x faster because it only needs to look up and return a single file version rather than reconstructing an entire VM state.

Does Sprites provide an audit trail for file changes?

No. Sprites provides VM-level checkpoints but does not track individual file operations. There is no log of which files were written, what changed, or when. Undisk records every file mutation with timestamps, agent identity, content hashes, and operation metadata.

Can I use Undisk and Sprites together?

Yes. Sprites provides the execution environment (a full Linux VM) while Undisk provides versioned file storage. Your agent runs code inside Sprites and reads/writes files through Undisk's MCP tools. This gives you both full Linux capabilities and per-file undo with audit trails.

Which is better for EU AI Act compliance?

Undisk. Sprites has no audit trail, no tamper-evident logging, and no configurable retention policies. Undisk provides content-addressed, append-only operation logs with configurable retention (default 180 days) — the primitives needed for EU AI Act Article 12 record-keeping requirements.