Introducing Mesa: a versioned filesystem for agents

Imagine you’re building a legal-tech agent that can help with real-estate transactions.

The v1 was a simple chat-with-the-docs app implemented with a RAG pipeline and some LLM calls chained together using some framework like LangChain or AI SDK.

Now you want to build a v2 that can execute on more critical tasks such as drafting LOIs, redlining contracts, and co-ordinating signatures on documents. You reach for a pre-built agent harness like the Agent SDK, spin up a sandbox, and make fast progress until you hit a wall:

• How do you persist your documents beyond the lifetime of your ephemeral sandbox?
• How do you give your agent fine-grained control over which documents it can use for context and which documents it's allowed to edit?
• How do you build approval workflows for sensitive edits and give your humans full control over reverting any mistaken changes?

Swap real-estate documents for case files, insurance claims, audit reports, patient records, or pull requests, and the shape of the problem is identical.

Every team building enterprise agents has the same wishlist: enable parallel agent execution, comprehensive access controls, and human-in-the-loop workflows. The problem is that none of the primitives including the harnesses, sandboxes, and even cloud filesystems make this easy.

Mesa was built to fill that gap.

Introducing Mesa

Mesa is a fully posix-compatible, durable filesystem with built-in version control designed to connect your agents to the documents they need while giving you full control over how those documents change.

Mesa is perfect for teams building enterprise agents that consume, produce, and edit long-lived documents in settings where you need human approvals, parallel agent execution, and audit trails such as code, legal, healthcare, insurance, research, real estate, and more.

Today we’re announcing our private beta and would love to help your team simplify your stack and level up your agents capabilities.

Why agents need a smarter filesystem

A new agent infrastructure stack is forming. Model providers handle intelligence. Harnesses handle orchestration. Sandboxes handle isolation. The missing layer is storage, but none of the existing storage primitives were designed for agents.

The artifacts modern agents produce don't behave like files in a bucket. They behave like a versioned codebase. They're created at high velocity, edited by humans and other agents in parallel, go through drafts, reviews, approvals, and rollbacks, and they have history that matters: every change has an author, a justification, and consequences.

Code repositories solved these problems decades ago with branches, merges, diffs, durable history, fine-grained access control, audit trails. The tooling for managing code is some of the most battle-tested infrastructure in software but it was built for small text files, designed for human UX, and run on services like GitHub that were never intended to absorb agent-scale write traffic.

Mesa generalizes that toolkit to any file type, at agent scale. Every document — a contract, a claims file, a research report, a CSV, an audio transcript — gets the storage primitives of a code repository:

• branches so agents can work in parallel without locking
• automatic durability so no work is ever lost when a sandbox dies
• fine-grained history so any change can be reviewed, rolled back, or replayed
• sparse materialization so massive sets of documents load instantly and only files needed by the agent are fetched on demand
• and access control so different agents can only read and write to the appropriate files

All of this is exposed as a POSIX-compatible filesystem that can be transparently dropped into whatever environment your agent is running in so it can use all the common unix tools it's been trained to use.

Before Mesa teams would fill in the gaps by combining tools that weren't built for this.

S3 and other cloud filesystems give you durable storage but no version semantics. No branches, no diffs, no easy history management, no way to stage edits for review. Concurrent writes clobber each other silently.

GitHub and GitLab give you the version semantics, but they were built for internal engineering teams. Their rate limits, large-file behavior, and organization modeling don't scale with agents. Git itself is powerful but you pay a latency tax to clone your files to your sandbox, it's not ergonomic for large non-text files, and it's not easy to load just the files your agent needs for a given session within a large repository.

Your agents don't want to git clone and git push, they just want to read and write files from the filesystem.

Mesa is the first storage layer that combines the interface of a filesystem with full version-control semantics, designed from the ground up for agent workloads.

Designed for developer productivity

Mesa can be used in several ways depending on your agent's runtime environment.

The most common pattern is to mount Mesa onto the operating system with FUSE so any application in the sandbox or server can read and write Mesa files like normal local files.

1# Install mesa and related dependencies
2curl -fsSL https://mesa.dev/install.sh | sh
3
4# Mount Mesa with the FUSE daemon running in the background
5mesa mount --daemonize
6
7# Run your agent in the Mesa directory
8cd ~/.local/share/mesa/mnt && claude

If you are running somewhere that cannot use a FUSE mount, Mesa also supports application-level mounting through our SDKs.

1import { Mesa } from "@mesadev/sdk";
2
3const mesa = new Mesa({
4  apiKey: process.env.MESA_API_KEY,
5});
6
7const fs = await mesa.fs.mount({
8  repos: [
9    { name: "project-foo", bookmark: "session-123" },
10    { name: "agent-skills", bookmark: "main" },
11  ],
12  mode: "rw",
13  cache: {
14    diskCache: {
15      path: "/tmp/mesa-cache",
16      maxSizeBytes: 1024 * 1024 * 1024,
17    },
18  },
19});

From there, you can perform standard filesystem operations through the SDK or give your agent a bash tool powered by Vercel's just-bash, providing an in-process simulated bash environment backed by Mesa.

1const fileContent = await fs.readFile("/project-foo/src/foo.md");
2await fs.writeFile("/project-foo/src/bar.md", "hello world");
3
4const result = await fs.bash({ cwd: "/project-foo/src/" }).exec("ls");

Each SDK mount point is fully isolated and enforces its own access controls. That makes it easy to run many Mesa-backed agent sessions on the same multi-tenant server while giving every agent the exact filesystem permissions it needs.

The result is a durable, versioned filesystem that works across harnesses, sandboxes, and runtime environments.

Use Mesa today

Mesa is in private beta and early design partners are already using it in production today across legal, healthcare, GTM, business operations, and coding agents.

If you're building enterprise agents that produce, edit, or coordinate long-lived documents, we want to talk. The fastest way in is the waitlist below or email us directly.

Public beta and v1.0 are coming in the next few months. The shape of the product is already clear; what comes next is making it available to everyone.