The Abstraction Problem

Every era of computing eventually settles on a core abstraction. Mainframes had jobs. Unix had files. The web had URLs. Mobile had apps. Each abstraction defined how humans and machines interacted with the system, and each was shaped by the dominant actor of its time.

Now the dominant actor is changing. AI agents are becoming first-class participants in computing systems — reading, writing, reasoning, and acting. But we are asking them to work through abstractions designed for a different era: REST APIs, SQL databases, message queues. These interfaces were built for human programmers to wire together. They are opaque to AI.

The Agentic File System (AFS) is our answer: return to the file system as the universal abstraction, but redesign it for a world where both AI and humans are actors.

Why Files?

The file system is the one abstraction that both humans and AI already understand natively.

Humans understand files. We have decades of muscle memory around creating, organizing, reading, and sharing files. Every operating system teaches this metaphor from day one.

AI understands files too. Large language models are trained on files — code files, documents, configuration files, data files. When an AI agent needs to understand a system's state, handing it a file is the most natural interface possible.

No other abstraction has this property. Databases require query languages. APIs require documentation. Message queues require protocol knowledge. But files? Files are self-evident.

Everything is File, View, Context, Identity

AFS extends the Unix "everything is a file" philosophy with four primitives:

File — the fundamental unit of storage and meaning. Not just bytes on disk, but any addressable resource: a document, a configuration, a dataset, a model, a conversation history.

View — a projection of a file for a specific consumer. The same underlying data can present different views to different actors. A database table is a structured view for an application. A natural language summary is a view for a human. A JSON schema is a view for an AI agent. The view is the soul of AFS — it transforms raw data into consumable meaning.

Context — the ambient information that shapes how a file is interpreted. Who is reading it? What task are they performing? What permissions do they have? Context flows through the file system automatically, so every access is situated.

Identity — every actor in the system has a decentralized identity (DID). Files know who created them, who modified them, and who is reading them. Identity is not bolted on as an afterthought — it is woven into the file system itself.

View as the Soul

The most important concept in AFS is the View. Traditional file systems store data and leave interpretation to the consumer. AFS inverts this: the system knows how to present data appropriately for each consumer.

When a human opens a project status file, they see a formatted dashboard. When an AI agent opens the same file, it sees structured data with semantic annotations. When an auditor opens it, they see the full change history with identity attribution.

Same file. Different views. Each one optimized for its audience.

This is not a rendering trick. It is a fundamental architectural choice. The view layer is where AI-native engineering meets system design — the system actively participates in making its own state legible.

Path as Protocol

In AFS, file paths are not just addresses — they are a protocol. The path structure encodes meaning:

  • /agents/booking-agent/config — an agent's configuration
  • /agents/booking-agent/state/current — an agent's current state
  • /agents/booking-agent/logs/2026-02-10 — an agent's activity log

Any actor — human or AI — can navigate this structure intuitively. Paths are discoverable, hierarchical, and self-documenting. You do not need an API reference to understand what /agents/booking-agent/state/current contains.

This makes AFS inherently inspectable. When something goes wrong, you do not need specialized debugging tools. You browse the file system.

AFS-UI: Files as Interface

AFS-UI extends the file system metaphor to user interfaces. If every piece of application state is a file, and every file has views, then the UI is simply the visual projection of the file system.

This means applications built on AFS do not have a separate "frontend" and "backend" in the traditional sense. The file system is the single source of truth, and the UI is one of its views — alongside the API view, the agent view, and the audit view.

ArcSphere is the reference implementation of AFS-UI, providing the visual layer that makes AFS-based systems accessible to non-technical users.

Academic Validation

The AFS architecture was accepted for presentation at the International Conference on Software Architecture (ICSA) 2026. The peer review process validated several core claims:

  • The file system abstraction reduces cognitive overhead for both human developers and AI agents
  • View-based projection enables multi-actor systems without data duplication
  • Identity-aware file operations provide auditability without external logging infrastructure

We believe this academic validation is important — not as a credential, but as evidence that the ideas hold up under rigorous scrutiny.

Building on AFS

AFS is not a standalone product. It is the abstraction layer that connects AIGNE (the agent framework), Blocklet Server (the deployment platform), and ArcSphere (the user interface). Every component in the ArcBlock stack speaks AFS natively.

If you are building AI-native applications, AFS gives you a foundation that is inspectable, composable, and identity-aware — without sacrificing the simplicity that made file systems the most successful abstraction in computing history.

Explore AFS

Learn more about the Agentic File System and how it powers AI-native applications.

Read the Docs | View on GitHub

Recommended Reading