# Rift

> Rift is the universal filesystem for agents. Files an agent writes on one machine appear on every machine that was given access, encrypted end to end. It runs from a command called `rift`.

Every page on this site has a Markdown version at the same address plus `.md`. The home page is at `/index.md`.

> **If you are an AI agent**, read [setup.md](https://rift.sh/setup.md) to install and join Rift, and [skill.md](https://rift.sh/skill.md) for the commands.

## When to use Rift

- Keep what an agent writes after its sandbox is gone.
- Give one agent one folder, as read or write, and take it back later.
- Move files between machines, clouds and owners without a party in the middle that can read them.
- Hand a file from one agent to another.

## Install

- Check first: `rift status`. If the command is not found, run `~/.local/bin/rift status`. If either one answers, do not install or join yet. Read setup.md.
- Install: `curl -fsSL https://rift.sh/install | sh`
- Token: the person runs `rift invite <name>` on their own machine
- Join: `rift init --invite <token>`
- Verify: `rift status` prints Rift's folder
- Full agent setup: [setup.md](https://rift.sh/setup.md)

## Docs

- [Get started](https://rift.sh/docs.md): Install Rift, create a key and share a first folder.
- [For agents](https://rift.sh/docs/agents.md): How an agent installs Rift, joins a filesystem, asks for access and checks that it is in sync.
- [Use Rift with your agent](https://rift.sh/docs/use-with.md): Where each agent product keeps a standing instruction, and what its sandbox allows.
- [Files](https://rift.sh/docs/files.md): Folders, and how to add, list, read, move and copy files.
- [Sharing](https://rift.sh/docs/sharing.md): Share a folder with a key, choose a role, restrict a path and remove access.
- [Guides](https://rift.sh/docs/guides.md): Add an agent, give a short-lived run its own key, deploy from a folder and connect Rift Cloud.
- [Commands](https://rift.sh/docs/commands.md): Every command with one line on what it does.
- [What is Rift?](https://rift.sh/docs/what-is-rift.md): What Rift is, who it is for and how it works, in one page.
- [Use Rift with E2B](https://rift.sh/docs/use-with/e2b.md): E2B runs the code and Rift keeps the files. Rift runs on Linux, which is what an E2B sandbox runs.
- [Use Rift with Daytona](https://rift.sh/docs/use-with/daytona.md): Daytona runs the code and Rift keeps the files. Rift runs on Linux, which is what a Daytona Linux sandbox runs.
- [Use Rift with Modal](https://rift.sh/docs/use-with/modal.md): Modal runs the code and Rift keeps the files. Rift runs on Linux, which is what a Modal container runs.
- [Use Rift with Sprites](https://rift.sh/docs/use-with/sprites.md): A Sprite runs the code and Rift keeps the files. Rift runs on Linux, which is what a Sprite runs.
- [Use Rift with Vercel Sandbox](https://rift.sh/docs/use-with/vercel-sandbox.md): Vercel Sandbox runs the code and Rift keeps the files. Rift runs on Linux, which is what the sandbox runs.
- [Use Rift with Mem0](https://rift.sh/docs/use-with/mem0.md): An agent can keep facts in Mem0 and files in Rift.
- [Use Rift with Supermemory](https://rift.sh/docs/use-with/supermemory.md): An agent can keep what it has learned in Supermemory and the files it works on in Rift.
- [Use Rift with Zep](https://rift.sh/docs/use-with/zep.md): An agent can keep facts in Zep and files in Rift.
- [Use Rift with Rivet Actors](https://rift.sh/docs/use-with/rivet-actors.md): A Rivet Actor can hold an agent's session state and schedule, and a Rift folder can hold the files it writes, on a worker that runs as a long-lived process on a machine you operate.
- [Use Rift with MCP](https://rift.sh/docs/use-with/mcp.md): An agent can call tools through MCP and keep its files in Rift.
- [Use Rift with A2A](https://rift.sh/docs/use-with/a2a.md): One agent can hand another a task over A2A while both keep their files in Rift.
- [Use Rift with ANP](https://rift.sh/docs/use-with/anp.md): Agents can find and message each other over ANP and keep their files in Rift.
- [Use Rift with SLIM](https://rift.sh/docs/use-with/slim.md): Agents can talk over SLIM and keep their files in Rift.
- [Use Rift with Tailscale](https://rift.sh/docs/use-with/tailscale.md): Tailscale connects machines, and Rift syncs files.
- [Use Rift with GitHub](https://rift.sh/docs/use-with/github.md): Git holds the source and its history. Rift carries what Git leaves behind, such as reports, datasets, screenshots and video. Git's FAQ says not to use a cloud syncing service on any part of a repository, and that applies to Rift too.

## Product

- [Overview](https://rift.sh/index.md): What Rift does, shown as a tour, with the prompt that adds an agent.
- [Security](https://rift.sh/security.md): What is encrypted, who can read what, and the limits.
- [How Rift compares](https://rift.sh/compare.md): An index of comparisons with other storage, sandboxes, hosted agents, memory services and protocols.

## Agent resources

- [Skill](https://rift.sh/skill.md): setup, commands and common mistakes
- [Setup playbook](https://rift.sh/setup.md): install, join and verify, step by step
- [Skills index](https://rift.sh/.well-known/agent-skills/index.json): lets `npx skills add https://rift.sh` find the skill
- [Full docs in one file](https://rift.sh/llms-full.txt)

## Optional

- [Rift vs Archil](https://rift.sh/compare/rift-vs-archil.md): Archil is a fast shared disk for AI workloads. Rift shares single folders, encrypted so that whoever stores them cannot read them.
- [Rift vs Mesa](https://rift.sh/compare/rift-vs-mesa.md): Mesa is a versioned filesystem where every agent write is a commit. Rift syncs folders that only your keys can read.
- [Rift vs Fastio](https://rift.sh/compare/rift-vs-fastio.md): Fastio gives each agent an account in a hosted workspace. Rift gives each agent a key and needs no account.
- [Rift vs Cloudflare Artifacts](https://rift.sh/compare/rift-vs-cloudflare-artifacts.md): Artifacts gives every agent task its own Git repository. Rift syncs whole folders, including the files Git does not track.
- [Rift vs AgentFS](https://rift.sh/compare/rift-vs-agentfs.md): AgentFS keeps one agent's files in a single database file. Rift keeps files in sync across machines and owners.
- [Rift vs E2B](https://rift.sh/compare/rift-vs-e2b.md): E2B runs agent code in isolated cloud sandboxes. Rift keeps the files those runs produce on machines you own.
- [Rift vs Daytona](https://rift.sh/compare/rift-vs-daytona.md): Daytona runs long-lived sandboxes for agents. Rift syncs a folder between any machines, in a sandbox or out of one.
- [Rift vs Modal](https://rift.sh/compare/rift-vs-modal.md): Modal runs containers and GPU jobs at scale. Rift syncs files between the machines you already have.
- [Rift vs Sprites](https://rift.sh/compare/rift-vs-sprites.md): A Sprite is a cloud computer that keeps its disk. Rift syncs a folder to machines you own.
- [Rift vs Vercel Sandbox](https://rift.sh/compare/rift-vs-vercel-sandbox.md): Vercel Sandbox runs agent code inside your Vercel project. Rift syncs an agent's files to your own machines.
- [Rift vs Claude Managed Agents](https://rift.sh/compare/rift-vs-claude-managed-agents.md): Managed Agents gives hosted Claude agents a shared memory directory. Rift gives any agent, on any machine, the same files.
- [Rift vs OpenAI Agents API](https://rift.sh/compare/rift-vs-openai-agents-api.md): The Agents API gives each session its own hosted workspace. Rift gives every session the same files.
- [Rift vs Letta](https://rift.sh/compare/rift-vs-letta.md): Letta keeps shared agent memory in Git repositories on Letta Cloud. Rift keeps any files in sync across any machines.
- [Rift vs Mem0](https://rift.sh/compare/rift-vs-mem0.md): Mem0 stores facts an agent has learned about a user. Rift syncs the files an agent works on.
- [Rift vs Supermemory](https://rift.sh/compare/rift-vs-supermemory.md): Supermemory turns conversations and documents into searchable memory on its servers. Rift syncs files between machines without reading them.
- [Rift vs Zep](https://rift.sh/compare/rift-vs-zep.md): Zep builds graphs of dated facts from conversations and business data and serves them from Zep Cloud. Rift syncs files between machines.
- [Rift vs Rivet Actors](https://rift.sh/compare/rift-vs-rivet-actors.md): A Rivet Actor is a long-lived process that keeps one agent's state, queue and connections. Rift syncs the files an agent writes to every machine that was given access.
- [Rift vs MCP](https://rift.sh/compare/rift-vs-mcp.md): MCP is how an agent calls a tool. Rift is where an agent's files live.
- [Rift vs A2A](https://rift.sh/compare/rift-vs-a2a.md): A2A is how agents from different vendors hand each other tasks. Rift is how they share files.
- [Rift vs ANP](https://rift.sh/compare/rift-vs-anp.md): ANP gives agents identities and encrypted messages. Rift gives them shared files.
- [Rift vs SLIM](https://rift.sh/compare/rift-vs-slim.md): SLIM is encrypted group messaging for agents. Rift is an encrypted filesystem for agents.
- [Rift vs Syncthing](https://rift.sh/compare/rift-vs-syncthing.md): Syncthing keeps whole folders identical across devices. Rift also shares part of a folder with an agent, as read or write, and keeps files available while your machines are off.
- [Rift vs Tailscale](https://rift.sh/compare/rift-vs-tailscale.md): Tailscale connects your machines. Rift syncs and stores the files on them.
- [Rift vs Amazon S3](https://rift.sh/compare/rift-vs-s3.md): S3 is object storage with grants that AWS checks. Rift is a synced filesystem with grants that your own machines check.
- [Rift vs GitHub](https://rift.sh/compare/rift-vs-github.md): GitHub moves the files Git tracks, one repository at a time. Rift moves every file in a folder.
- [Rift vs Dropbox](https://rift.sh/compare/rift-vs-dropbox.md): Dropbox shares folders between accounts, and an agent signs in as a person. Rift gives each agent a key of its own.
- [Rift vs Google Drive](https://rift.sh/compare/rift-vs-google-drive.md): Google's Drive MCP server gives an agent read access to a person's whole Drive. Rift gives an agent its own key and only the folders it was granted.
- [Rift vs Proton Drive](https://rift.sh/compare/rift-vs-proton-drive.md): Proton Drive is end-to-end encrypted storage for people. Rift is end-to-end encrypted storage in which each agent holds its own key.
- [Company](https://rift.sh/company.md): The question Rift works on and the argument behind it.
- [Blog](https://rift.sh/blog.md): News and essays from Rift.
- [Introducing Rift](https://rift.sh/blog/introducing-rift.md): Rift puts everything your agents write in one place you own.
- [The six jobs of file sync](https://rift.sh/blog/the-six-jobs-of-file-sync.md): Sharing a folder takes six jobs. See who does each one in eight systems, from Dropbox to Rift.
- [Careers](https://rift.sh/careers.md): What we build, what we care about and the open roles.
- [Member of Technical Staff, Sync](https://rift.sh/careers/sync.md): You will own how files move between machines. A file written on one machine should reach every other machine as fast as the network allows, and it should still arrive after machines sleep and connections drop.
- [Member of Technical Staff, Cryptography](https://rift.sh/careers/cryptography.md): You will own how Rift decides who can read what. Your work is the reason we can say that we cannot read a user's files.
- [Member of Technical Staff, Agent Infrastructure](https://rift.sh/careers/agent-infrastructure.md): You will make Rift the default place agents keep their work. Rift is built for agents first, and you will measure whether they succeed.
- [Member of Technical Staff, Product Engineering](https://rift.sh/careers/product-engineering.md): You will own what Rift is like to use, from the first install to the day a team runs hundreds of agents.
- [Privacy policy](https://rift.sh/privacy.md): What Rift collects and what it cannot see.
- [Terms of service](https://rift.sh/terms.md): The terms for the services Rift operates.