Mesa
Product · Filesystem

A virtual filesystem for wherever your agents run.

Mount Mesa repositories as local directories, or run them in-process with no sandbox at all. Both interfaces share the same fast cache, smart prefetching, and automatic version history.

Read docs
1.0OVERVIEW

Your agents work with files. We make them feel local.

Most agent platforms force a choice: clone the repo and pay the latency tax up front, or build a custom file API and lose every tool that expects POSIX. The Mesa filesystem gives you the ergonomics of a local directory with the persistence and versioning of a managed service.

Files materialize on demand. Writes are durable the moment they return. Every change is captured in version history. There is no clone step, no sync step, and nothing to keep in sync.

50ms
Time to first file read
vs. minutes for a full clone
2
Interfaces, one filesystem
FUSE mount · in-process bash
2.0TWO INTERFACES

One filesystem. Two ways to plug it in.

Pick the interface that matches your runtime. Both modes use the same underlying caching, prefetching, and version history — you can switch between them or use them side-by-side.

OS-level

FUSE mount

Mount Mesa repositories as real directories on macOS or Linux. Every process on the box sees standard files at a normal mount path.

Use it when
  • Your agent runs inside a full VM or container you control
  • You need sidecar processes (LSPs, build tools, test runners) sharing the same files
  • Your agent executes arbitrary binaries that expect a real POSIX filesystem
# Install
$ curl -fsSL https://mesa.dev/install.sh | sh


# Mount Mesa as a real directory on disk
$ mesa mount --daemonize


# Use any tool that reads files - no clone required
$ ls ~/.local/share/mesa/mnt/acme/agent-workspace
$ grep -r "TODO" ~/.local/share/mesa/mnt/acme/agent-workspace/src
$ cursor ~/.local/share/mesa/mnt/acme/agent-workspace
Best forSandboxes, dev environments, build systems, language servers
App-level

Mesa SDK

Run a sandboxed bash shell against Mesa entirely in-process via the @mesadev/sdk package. No FUSE, no container, no mount point.

Use it when
  • You're deploying to a serverless runtime with no mount access
  • Your agent's workload is primarily reading and writing files
  • Time-to-first-token latency matters — skip cold-start mounts
import { Mesa } from "@mesadev/sdk";


const mesa = new Mesa({ apiKey: process.env.MESA_API_KEY });


// Mount in-process - no FUSE, no sandbox, no clone
const fs = await mesa.fs.mount({
  repos: [{ name: "agent-workspace", bookmark: "main" }],
  mode: "rw",
});


// Run shell commands directly against Mesa repos
const bash = fs.bash({ cwd: "/acme/agent-workspace" });
const { stdout } = await bash.exec("ls src && cat README.md");
Best forBackend agents, multi-tenant apps, serverless runtimes
3.0CAPABILITIES

A real filesystem, with the ergonomics of a managed service.

No clone, no wait

Reads materialize files on demand and writes persist directly to Mesa. Skip the multi-minute clone for a multi-gigabyte monorepo.

Smart prefetching

Mesa uses intelligent prefetching based on access patterns so listings and common file reads return instantly.

Local caching

Configurable on-disk cache with size limits. Frequently accessed files are served from local storage, not the network.

Automatic versioning

Every write is automatically persisted and durable. Versioning is built-in while still giving you full control over named checkpoints.

Works with every tool

Editors, language servers, build systems, grep, agents — anything that reads files works out of the box. No SDK or shim required.

Built for large files

Random-access reads on multi-gigabyte files with no per-file size limit. Store code, datasets, models, and media in one workspace.

4.0HOW IT WORKS

Files on demand, with a hot local cache.

Client
Your agent
open() · read() · write()
POSIX · FUSE · SDK
MesaFS
Cache
Prefetch
Backend Server
Mesa
1. Read

Your agent reads files just like it normally does, with Mesa handling materialization of files and smart caching for improved performance.

2. Prefetch

In the background, Mesa prefetches intelligently based on accesss patterns so directory listings and common reads stay sub-100ms.

3. Persist

Writes are automatically persisted and durable. No manual save or pushing required.

5.0USE CASES

Built for the way agents actually run.

Sandbox & VM agents

Mount Mesa inside Daytona, E2B, Modal, or any container. Your agent gets a real working directory with no egress for filesystem reads.

In-process backend agents

Skip the sandbox entirely. Use the just-bash SDK to give a Node.js agent a fully isolated, multi-tenant filesystem in a single npm install.

Dev environments & IDEs

Open mounted repos in Cursor, VS Code, or your terminal. Read instantly across hundreds of repos without ever running git clone.

Stop cloning repos to read a single file.

Mount Mesa once and let your agents read, write, and version files like they’re local.

Quickstart