Key Moments
AI Dev 26 x SF | Carter Rabasa: File Systems Are the New Primitive for AI Agents
DeepLearning.AIWant to know something specific about what's covered?
We've already dissected every moment. Ask and we will deliver (with timestamps).
Key Moments
LLMs are already masters of file systems due to decades of training, yet developers keep building custom APIs for AI agents instead of leveraging this innate capability, making development unnecessarily complex.
Key Insights
90% of enterprise data is unstructured, yet traditional software development often focuses on the remaining 10% residing in relational or NoSQL databases.
LLMs possess extensive training on Unix/Linux file system commands and semantics, which can be leveraged for agent development, eliminating the need for bespoke APIs.
Agent skills, like Claude.md and Langchain's approach, are increasingly standardized around file system structures (directories, skill.md files) because LLMs natively understand them.
OpenAI's Agent SDK now supports remote file system mounts, allowing agents to interact with cloud storage like Box as if it were a local file system.
Leveraging file systems for agent-human interaction simplifies development by providing a shared, intuitive interface, reducing the need to build custom web or Slackbot interfaces.
The Unix philosophy of building complex systems from simple, atomic building blocks (like file descriptors representing various resources) is highly relevant for modern AI agent design.
The overlooked potential of file systems for AI agents
The prevailing approach to AI agent development has often overlooked the inherent capabilities of Large Language Models (LLMs) regarding file systems. Despite LLMs being trained on vast amounts of code, operating systems, and file-based workflows, developers frequently resort to building custom APIs and complex data schemas. This is particularly surprising given that 90% of enterprise data is unstructured (PDFs, Word docs, etc.), a domain where file systems naturally play a crucial role. The traditional focus on relational and NoSQL databases, which constitute only about 10% of how work gets done, has led to a significant underutilization of LLMs' pre-existing expertise in manipulating file structures. This talk argues that file systems should be considered the new primitive for building AI agents, as they provide a powerful, intuitive, and readily understood foundation for memory, state, and agent capabilities.
Why file systems are a natural fit for LLMs
LLMs have been inadvertently trained on decades of file system semantics. Every command-line interface, every GitHub repository, every Linux man page has contributed to an LLM's deep understanding of how directories are structured, how files are organized, and how to perform operations like `ls`, `cat`, `grep`, and `write`. This ingrained knowledge means that introducing file system operations to an agent requires little to no retraining. Developers can leverage this 'prior,' meaning the model's existing knowledge, rather than spending effort teaching it bespoke systems. The Unix philosophy, which emphasized building complex systems from simple, atomic building blocks represented by file descriptors, is directly applicable here. This principle allows for radical complexity to be engineered on top of simple, uniform interfaces, which is precisely what file systems offer to LLMs.
File system semantics enable effective long-term memory
A critical challenge in agent development is providing long-term memory. Effective memory solutions must retain facts across sessions, retrieve information selectively, allow for updates and corrections, and be inspectable by operators. While databases like relational, NoSQL, or vector databases have their strengths, they often fall short on these criteria, especially human inspectability. File systems, however, naturally support these requirements. Agents can read and write files to store state, organize information in hierarchical directories, and update content. The non-deterministic nature of LLMs makes inspectability crucial, and file systems provide a human-readable layer for this. Moreover, cloud-based file systems, like Box, add benefits such as durability, versioning, and robust audit trails, making them ideal for enterprise-grade agent memory.
Emerging agent frameworks embrace file system paradigms
This shift towards file systems as a core primitive is already evident in popular agent development frameworks. For instance, Claude.md initially used simple markdown files to provide LLMs with skills and behavioral instructions, which has since evolved into the standardized concept of 'agent skills'—essentially directories with a `skill.md` file. Langchain's Deep Agents SDK utilizes file system semantics for its pluggable backend, supporting commands like `write file`, `edit file`, and `glob`. Similarly, OpenAI's Agent SDK now supports remote file system mounts, allowing agents to treat cloud storage, such as a Box drive, as a local workspace. These advancements demonstrate a recognition that LLMs are already proficient with file system operations, and developers should build upon this existing understanding rather than inventing new, bespoke interfaces.
Demonstrating file system-based agent interaction
A practical demonstration showcased how a simple Python application, with an agent defined in less than 20 lines of code, leverage Box files for team management. Markdown files (`team.md`, `tasks.md`) described team members and tasks. By marking a task as complete in a human-readable UI (Box), the agent, running via the OpenAI Agent SDK mounted to Box, detected the change. The agent then synchronized this update across both files using basic file system operations, without needing custom APIs or direct CLI access. This illustrates the power of human-in-the-loop systems where both humans and agents can interact with a shared file system, simplifying complex workflows and enhancing collaboration. The demonstration highlighted the agent's ability to introspect and synchronize data across denormalized files, embodying proactive task management through file manipulation.
Beyond local files: Unix's broader influence
The concept extends beyond traditional file storage. The Unix philosophy treated everything as a file descriptor, including running processes (`/proc`) and device I/O. This principle is highly relevant for agents. For example, accessing CPU information on a cloud VM can be done by reading from `/proc/cpuinfo`, treating system processes as files accessed via file system semantics. While not advocating for the complete abandonment of databases or APIs, the talk suggests building 'shims'—interfaces that translate agent needs into file system operations. An example is the Chroma team's collaboration with Mitlfi to create a `ChromaFS` shim, enabling access to Chroma data through file system semantics. This highlights how existing data stores can be integrated with agents by presenting their data in a file-like manner.
File systems as bridges for human and agent interaction
Leveraging file systems is advantageous not only for LLMs but also for human users involved in an agent's workflow. Instead of building bespoke web interfaces or Slack bots that require user training and significant development effort, developers can utilize shared file systems. This provides a common, intuitive interface that both humans and agents understand, drastically simplifying the development of collaborative agentic applications. As agent capabilities expand into broader computer use—like operating a Mac—understanding native file system operations becomes paramount. Cloud file systems further enhance this by offering durability, multi-user support, versioning, and enterprise-grade governance and permissions, making them a robust choice for many agent applications.
Riding the model's priors: the winning engineering principle
The core engineering principle for modern AI development is to 'ride the model's priors'—leverage what LLMs already know. Instead of spending time and resources retraining agents or developing custom solutions for every problem, engineers should seek existing paradigms and interfaces that LLMs are inherently trained on. File systems represent a massive, inherent 'prior' for LLMs. The talk concludes by reiterating the profound simplicity and scalability of Unix's initial idea: representing everything as a file. This foundational concept has powered some of the most complex systems ever built, and by neglecting it for bespoke, complex solutions, developers are missing out on a powerful, native capability of LLMs. The ongoing challenge is to remember and apply this elegant principle in building future AI agents, promoting productivity and innovation.
Mentioned in This Episode
●Products
●Software & Apps
●Companies
●Organizations
●Concepts
●People Referenced
Common Questions
The core argument is that file systems, due to their long history and the vast amount of training data LLMs have on them, serve as a highly effective and native primitive for AI agents, enabling better long-term memory and interaction.
Topics
Mentioned in this video
An operating system whose file system commands are fundamentally understood by all LLMs, making it a superior primitive for AI agents.
An SDK that allows defining workspaces for sandbox agents and supports remote file system mounts, including Box.
A relational database system mentioned as a potential, but ultimately less suitable, solution for long-term agent memory.
A well-known LLM that users have likely experimented with, often facing the problem of agents forgetting information.
An LLM mentioned in the context of agents needing long-term memory and its early use of markdown files for skills.
A framework with a deep agents SDK that leverages file system semantics for its pluggable backend system, enabling powerful agents.
A relational database system mentioned as a potential, but ultimately less suitable, solution for long-term agent memory.
A system that the Chroma team worked with Mitlfi to build a shim for, allowing access to Chroma data using file system semantics.
An operating system used on a Digital Ocean droplet to demonstrate interacting with the /proc directory via file system semantics.
A system that shipped an update with built-in computer use, capable of manipulating files on a Mac but less so custom applications.
Software required to be installed to get the Box Sandbox CLI demo up and running.
Databases discussed as a potential solution for agent memory, noted as fantastic for similarity search but narrowly useful.
The programming language used to build the demonstration application for the Box Sandbox CLI.
A relational database system mentioned as a potential, but ultimately less suitable, solution for long-term agent memory.
A platform whose repositories LLMs have been trained on, informing their native understanding of directory structures and files.
A cloud platform provider where a Ubuntu droplet was used to demonstrate file system interactions with the /proc directory.
A company where Carter Rabasa worked, contributing to his experience in developer tooling.
Co-inventor of Unix, whose work laid the foundation for powerful and simple systems built on atomic building blocks.
Co-inventor of Unix, whose work laid the foundation for powerful and simple systems built on atomic building blocks.
The speaker, who leads developer relations at Box and has over 26 years of software building experience, specializing in developer tools.
More from DeepLearningAI
View all 80 summaries
31 minAI Dev 26 x SF | Vlad Luzin: Herding Cats—The Hidden Challenges of Multi-Agent Autonomy
28 minAI Dev 26 x SF | Melissa Herrera: Your Agents Should Be Durable
43 minAI Dev 26 x SF | Paige Bailey: What's New and What's Next in AI
32 minAI Dev 26 x SF | Aditi Gupta: Building SRE Agents with the Redis Context Engine
Ask anything from this episode.
Save it, chat with it, and connect it to Claude or ChatGPT. Get cited answers from the actual content — and build your own knowledge base of every podcast and video you care about.
Get Started Free