The demo sounds almost too clean. Mount a petabyte of data in under 100 milliseconds. Fork an entire workspace in three milliseconds without copying a single byte. Watch ten thousand AI agents spin up isolated sandboxes, manipulate files, and leave perfect audit trails—all without the storage layer breaking a sweat.
Amulet, a two-person startup from Y Combinator's Summer 2026 batch, is making exactly those claims. Whether they can deliver at scale remains an open question. The company is in private beta, has published pricing but no customer logos, and its performance numbers come from internal benchmarks, not third-party validation. But here's the thing: dozens of venture-backed startups and all three major cloud providers are suddenly racing to solve the same problem Amulet claims to have cracked.
The problem? AI agents expect filesystems to behave like filesystems. They want to rename directories, fork workspaces, snapshot before risky operations—POSIX primitives that developers have relied on for half a century. But cloud infrastructure was built for different workloads entirely: web servers pulling static assets, batch jobs crunching training data, applications that treat S3 as a dumb bucket of objects.
That architecture is buckling under a new reality. According to a June 2026 Forrester analysis, roughly three-quarters of enterprise leaders reported adopting agentic AI. The Cloud Security Alliance found in April that 54% of organizations already have between one and 100 unsanctioned AI agents running loose in their environments—shadow IT for the autonomous software era. Gartner forecasts worldwide AI spending hitting $2.59 trillion in 2026, a 47% year-over-year jump, with infrastructure projected to consume more than 45% of that spend over the next several years.
Infrastructure vendors know what's coming. AWS launched S3 Files in April—a filesystem interface layered atop S3 promising single-digit millisecond latencies. Google unveiled its "Agentic Data Cloud" at its developer conference the same month. VAST Data and Cloudera announced a partnership in July to manage what they're calling an "AI factory" spanning 60 exabytes of customer data. The hyperscalers are retrofitting object stores and legacy network file systems for workloads they never anticipated.
And then there are the startups, betting that incumbents will move too slowly.
When Object Stores Meet Autonomous Software
The technical challenge is deceptively straightforward. An AI agent expects to mount a workspace, manipulate files, spawn child processes, leave an audit trail. Standard stuff. Now imagine ten thousand agents needing isolated copies of the same 100-terabyte training dataset. Naive cloning becomes absurd—and expensive. If those agents write conflicting updates to shared state, the last-writer-wins semantics from S3 adapters create silent data corruption. If regulators ask which agent modified which file when, a flat object bucket offers nothing resembling an answer.
Traditional cloud storage wasn't designed for this, and it shows. Amazon's Elastic File System provides NFS semantics, which works fine for conventional workloads. But AWS documentation updated this summer emphasizes performance tuning around IOPS ceilings and throughput consumed by metadata operations. There's no native branching. No versioned history. S3, meanwhile, is an object store; mounting it via FUSE adapters like s3fs-fuse or goofys leaks object semantics everywhere. A simple rename becomes copy-plus-delete. Small-file writes trigger 10-to-30-millisecond round trips per API call, according to JuiceFS documentation. Concurrency often devolves into chaos.
The industry spent years optimizing for training workloads—big sequential reads, checkpoint bursts, terabyte-scale throughput. WEKA publishes case studies where customers sustain 1 GB/s read per GPU. JuiceFS claimed 108 GiB/s read bandwidth at 10 nodes in MLPerf Storage benchmarks last year. Impressive numbers. But those benchmarks measure bulk transfer, not the metadata storm an agent-first world now demands.
Enterprise storage spending grew 22.9% year-over-year in the first quarter of 2026, per IDC, with AI workloads cited as the primary driver. According to Synergy Research analysis from August 2026, cloud infrastructure spending hit an eight-year high, with generative AI named as the dominant catalyst. The money is flowing. The infrastructure playbook is still catching up.
The Academic Case for Filesystem-First Design
A cluster of research papers published this year makes the case that filesystems are becoming the native interface between agents and persistent state. "Filesystem-Based Memory for LLM Agents," published on arXiv in late July, documents the growing practice of using operating system filesystems as long-term agent memory. "Quine: Realizing LLM Agents as Native POSIX Processes," from March, argues for mapping agent identity, interface, state, and lifecycle directly to OS primitives.
Perhaps most pointedly, Microsoft Research published "Don't Let AI Agents YOLO Your Files" in April—the first systematic study of agent filesystem misuse across 290 public reports and 13 frameworks. The conclusion: shifting information and control to filesystems is essential for both safety and autonomy.
Industry voices are echoing the academic chorus. Box published a blog post in June titled "Filesystems are the new primitive for AI agents." Archil, one of Amulet's competitors, published "The file system is the agent" around the same time. An independent manifesto-style piece at filesystem.md from February argues the filesystem should be the primary interface between agent, memory, identity, and execution environment.
The technical requirements crystallizing from this discourse are specific. Agents need POSIX-style mounts—not just object-store HTTP APIs—because models already understand file paths and shell commands. They need instant copy-on-write forks to spawn isolated workspaces without duplicating terabytes. They need content-addressed, versioned history for provenance and audit trails. They need conflict-safe publishing mechanisms so parallel agents can merge results without silent corruption.
Security and compliance pressures amplify the urgency. The Cloud Security Alliance noted that more than half of organizations already have unsanctioned agents deployed. A separate Forrester survey in June found 49% of security decision-makers cite agentic AI as a top concern. The EU AI Act's transparency obligations under Article 50 took effect in early August, with emphasis on logging, traceability, and technical documentation for high-risk systems. Persistent, versioned, attributable filesystems map directly to these audit requirements in ways that flat S3 buckets simply don't.
Google's "State of AI Infrastructure" report from July found that 43% of IT leaders cite integrating legacy APIs and data sources as the biggest gap in agentic infrastructure. McKinsey analysis from April argued that agentic AI infrastructure requires shared foundations and standards—a dual challenge to scale infrastructure while using agentic AI to contain rising costs. IBM reported in June that more than 75% of executives expect significant redefinition of service delivery driven by agentic operating models.
The question is no longer whether agents need better storage. It's which architecture will win.
The Startup Bet
Amulet's founders, Nithik Bala and Varun Puru, both spent time at Meta and Rockset (later acquired by OpenAI) before launching their company. They're building what they call an "agent-native filesystem" with four core features: POSIX-style mount, instant copy-on-write forks, content-addressed history, and conflict-safe publishing with provenance. Every commit records which agent, session, or run produced it. Mounts use short-lived bearer tokens pinned to a certificate authority, keeping object-store credentials out of agent sandboxes entirely.
The company published detailed technical explainers in late July, positioning itself directly against Archil, JuiceFS, AWS EFS, s3fs, Modal Volumes, and others. Their comparison matrix claims zero-byte forks until divergence, full deduplication across an account, and immutable snapshots as first-class primitives. Pricing is public—free tier, $500/month growth tier, custom enterprise—but no customer case studies are visible yet. The Y Combinator directory mentions work with "agentic automated-research labs, cloud agent providers" without naming names.
No third-party benchmarks have surfaced. The sub-100-millisecond mount claims and 3-millisecond fork performance rest on vendor-published materials. For a two-person company in private beta, that's perhaps expected. Whether those numbers hold under real-world load with demanding enterprise customers is a different question.
They're not alone in the race. Mesa, announced in late April and in private beta as of mid-year, offers a POSIX-compatible durable filesystem with built-in version control—branches, merges, diffs, audit history. Archil positions itself as "one filesystem, mounted everywhere," composing context from S3, Google Cloud Storage, and NFS, with versioning and checkpoints. The company publishes benchmarks (vendor-provided) alongside testimonials from customers like ComputeSDK and Clay. AgentFS, from the creators of Turso, isolates each agent's filesystem in a SQLite file, enabling instant snapshots and forks via single-file design.
The approaches differ in implementation details. But the pattern holds across all of them: native versioning, instant forks, provenance, isolation. These aren't afterthoughts bolted onto object stores. They're foundational design choices.
The Hyperscaler Response
AWS, unsurprisingly, moved first among the cloud giants. S3 Files launched April 7 as a generally available shared filesystem interface for S3 across AWS compute services. AWS blogs tout single-digit millisecond latencies for active data and integration with Lambda, CloudWatch, and CloudTrail. A late June blog post demonstrated mounting S3 Files from Lambda for persistent agent session state and shell command execution. S3 Annotations, announced mid-June, attach rich queryable metadata directly to objects—useful for AI and analytics data discovery, according to AWS.
But S3 Files doesn't claim built-in version control or agent provenance the way Amulet and its startup competitors do. It's a filesystem interface over an object store, not a filesystem architected from scratch for agent workloads. That's the positioning wedge the startups are exploiting.
Whether that wedge is durable depends on how quickly Amazon can iterate. The company has engineering depth and S3 adoption at planetary scale. If Amazon decides agent-native features matter strategically, it can move fast. Google's Agentic Data Cloud already spans BigQuery, AlloyDB, and Vertex AI; filesystem semantics could slot in as one more layer. The question is execution speed versus startup agility.
What Comes Next
The agent-native filesystem category is weeks old, not years. Amulet's founders graduated Y Combinator in August. Mesa announced in April. The research papers establishing filesystem-based agent memory as a pattern worth studying are dated March through July of this year. S3 Files is four months old.
It's early enough that no consensus architecture has emerged. Late enough that everyone senses the land grab beginning.
Forrester's cloud predictions from late last year and early this year forecast a hyperscaler race to AI-native infrastructure and competition for "agentic supremacy." The firm anticipates the rise of "neoclouds"—specialized infrastructure providers targeting workloads the big three weren't built for. Agent storage could be one such wedge. Zapier's agent adoption survey from January found 84% of enterprises planning to boost AI agent investments this year. If even a fraction hit storage bottlenecks with s3fs or EFS, the market opens quickly.
The technical challenges are real, though. Amulet's claims—sub-100-millisecond mounts, 3-millisecond forks—remain unverified by third parties. The company is two people in private beta with no disclosed funding beyond Y Combinator's standard terms. Mesa, Archil, and AgentFS are similarly early-stage.
Regulatory pressure will shape outcomes more than founders might prefer. EU AI Act transparency obligations took effect in August. NIST's AI Risk Management Framework is under active revision. Enterprise buyers increasingly demand audit trails, provenance, and governance hooks that flat object stores don't provide natively. Persistent, versioned filesystems with commit-level attribution align with compliance needs in ways that require less middleware. That's a tailwind for anyone building audit-first storage.
Research from late July evaluated POSIX storage for AI research workflows and found flash-backed NFS outperformed flash-backed Lustre by up to 3× for distributed checkpointing in specific environments. The lesson isn't that NFS always wins—it's that workload-specific filesystem design matters more than raw throughput. Agents generate metadata storms, conflicting writes, ephemeral forks. Optimizing for those patterns requires different trade-offs than optimizing for training checkpoints.
For founders building AI products, the calculus is shifting. A year ago, mounting S3 via goofys and hoping for the best was standard practice. Now there are POSIX-native options with instant forks and version control—if you're willing to bet on pre-revenue startups or wait for AWS to catch up. CTOs evaluating agent platforms need to ask whether their storage layer supports the concurrency, provenance, and isolation their compliance team will demand six months from now. Investors tracking infrastructure should watch which companies land the first reference customers at scale.
Whoever proves they can handle ten thousand agents forking petabyte datasets without breaking a sweat will have pricing power. Maybe that's Amulet. Maybe it's a hyperscaler feature launch six months from now. Maybe it's a company that hasn't announced yet.
The filesystem isn't a new idea—it's a 50-year-old abstraction. What's new is the workload: autonomous agents that treat filesystems as both memory and execution environment, spawning and merging state at machine speed. The infrastructure that powers that workload is being written right now, in private beta channels and hyperscaler roadmaps. The only certainty? Object stores and NFS won't be enough.
