Perplexity Projects: A Git-Style File System for AI Agents

As AI agents move from single conversations toward long-term collaboration, a core question emerges: how do agents' work outputs accumulate, get shared, and persist? The Perplexity team offers one answer in its Projects feature—turning the file system into a Git repository designed for agents.

Core Design: A Git Forge for Agents

The backend file system of Perplexity Projects is not a traditional storage solution. Instead, it is designed as a "Git forge"—a code hosting platform dedicated to agent collaboration. According to the Perplexity team's introduction on social platforms, each agent works in an independent sandbox environment and commits its results to a shared repository. This means agents' outputs are not temporary files scattered around, but are versioned and traceable like code commits.

The cleverness of this design lies in borrowing a proven collaboration model from software development. Developers have long been accustomed to distributed collaboration via Git, where each contributor works on a local branch and then merges into the main repository. Perplexity transplants this paradigm to the AI agent context, making agents "contributors" rather than isolated tool calls.

Git forge refers to a code hosting and collaboration platform built on the Git protocol, with typical examples including GitHub, GitLab, and Gitea. Its core capability goes far beyond storing code; around version control, it provides a full set of collaboration mechanisms such as branch management, commit history, code review, merge requests, and permission control. Calling a file system a "Git forge" means it does not merely passively store files, but actively provides agents with collaboration infrastructure similar to a developer community: every output is treated as a commit, with a timestamp, author identity, and change record, making it traceable, rollback-capable, and experimentable through branching. For AI agents, this is equivalent to equipping them with a shared "work logbook" and "version safe," upgrading collaboration among agents from temporary message passing to persistent, structured engineering practice.

The Balance Between Sandbox Isolation and a Shared Repository

The system adopts a two-layer structure of "sandbox isolation + shared repository." Each agent has its own sandbox, ensuring runtime security and independence—when executing tasks, an agent will not interfere with other agents' working environments. At the same time, however, the agent's outputs are committed to a shared repository, enabling human users and other agents to continue building on top of them.

This architecture resolves a key contradiction: agents need isolation for security, but they also need sharing for collaboration. Traditional multi-agent systems often struggle to balance the two—either complete isolation leads to information silos, or complete sharing introduces security risks. Perplexity's approach achieves controlled information flow through the act of "committing."

Sandbox is a security isolation mechanism that prevents code or agent behavior from damaging the host environment by restricting the resources a process can access, such as the file system, network, and system calls. In a multi-agent system, each agent runs in an independent sandbox, meaning that even if an agent performs an erroneous or malicious operation, the impact is confined to its own container and does not affect other agents or the underlying system. This complements the shared repository: the sandbox safeguards the runtime security boundary, while the shared repository allows vetted results to enter the public space through explicit "commit" actions. This design draws on the idea of process isolation in operating systems and also echoes the principle of "isolate failures, share data" in microservice architecture, thereby achieving a dynamic balance between security and collaboration.

A Breakthrough in Cross-Session Workflows

More noteworthy is the capability across sessions. A fundamental limitation of traditional AI conversations is the "session boundary"—after each conversation ends, the context disappears, and it is difficult for work outputs to persist. Through persistence at the file system level, Perplexity Projects allows agents' work to continue accumulating across multiple interactions.

For tasks that require multiple steps and a long time to complete, this capability is crucial. For example, an agent generates a data analysis script in the first session, and in the second session another agent can continue working based on that script without starting from scratch. The file system becomes the "shared memory" among agents.

Session boundary is a fundamental limitation of traditional conversational AI: each interaction is treated as an independent session, and after it ends the context window is cleared, so the model cannot automatically remember or continue previous work. This makes multi-step tasks difficult to advance continuously, and users often need to repeatedly paste historical information. Perplexity Projects breaks through this boundary through persistence at the file system level—agents' outputs are written into a shared repository, forming "external memory" independent of the session. Agents in subsequent sessions can read these files and thereby restore their working state. This mechanism is similar to giving AI agents long-term storage, allowing them to continue projects through code repositories rather than conversation history, just like human developers, greatly improving the feasibility and efficiency of tasks spanning long periods.

Implications for the AI Collaboration Paradigm

This practice by Perplexity points to a larger trend: AI agents are shifting from "going it alone" to "team collaboration." When agents can commit code, view history, and continue development based on others' work like software engineers, their productivity will be significantly amplified.

This model also brings new possibilities—humans and agents can collaborate in the same repository. Human users can see agents' commit records and understand their work logic; agents can also continue iterating based on human modifications. This human-machine hybrid collaboration workflow may be the standard form of future AI-native applications.

From a technical implementation perspective, abstracting the file system as a Git forge requires redesigning multiple layers, including storage, version control, and permission management. Perplexity's choice to publicly share this architectural idea also provides a reference sample worth considering for the entire industry. For teams building multi-agent systems, this "sandbox + shared repository" model is worth studying in depth.

One-line Summary

Perplexity Projects turns the file system into a Git repository for agents, enabling cross-session collaboration.

Paragraph Summary

Perplexity Projects proposes a file system architecture for AI agent collaboration, designing it as a "Git forge": each agent works in an independent sandbox, and outputs are committed to a shared repository, enabling versioned and traceable collaboration. This two-layer structure of "sandbox isolation + shared repository" resolves the contradiction between security and sharing among agents, and through file system persistence breaks through the session boundary of traditional conversations, allowing agent work to continue accumulating across multiple interactions. The article argues that this model marks a shift for AI agents from going it alone to team collaboration, and provides a new paradigm for human-machine hybrid collaboration, offering reference value for building multi-agent systems.