Skip to main content
Mesa supports versioning with simple checkpoints as well as complex branch-based workflows. We provide full Git compatibility but Mesa is far more powerful than a traditional Git hosting platform. You can read more about our versioning model here.

How it works

Use the Mesa TypeScript REST SDK to create a repo and commit files in one call. Mesa handles Git object storage, refs, and history behind the scenes. Use the SDK to create repositories on-demand and edit their contents through Mesa.
// Initialize the SDK
const mesa = new Mesa({ org: 'acme' });

// Create a repository - an isolated folder
// with its own version history and access controls
const repo = await mesa.repos.create({ name: 'my-workspace' });

// Open the repository locally as a virtual filesystem
const fs = await mesa.fs.mount({
  repos: [{ name: 'my-workspace', bookmark: 'main' }],
  mode: 'rw',
});
const bash = fs.bash({ cwd: '/acme/my-workspace' });

// Run an agent within the repository. All changes get persisted automatically.
await generateText({
  model: 'gpt-5.3-codex',
  prompt: 'Write a README for the repository',
  tools: {
    bash: tool({
      execute: ({ command }) => bash.exec(command),
      // ... other tool configuration ...
    }),
  }
});
Alternatively, you can use our Content API and commit-builder to read and edit files in the repository.
const file = await mesa.content.get({
  repo: 'my-workspace',
  path: 'README.md',
});

const featureBookmark = await mesa.bookmarks
  .list({ repo: 'my-workspace' })
  .find((bookmark) => bookmark.name === 'my-feature')!;

const change = await mesa.changes.create({
  repo: 'my-workspace',
  base_change_id: featureBookmark.change_id,
  message: 'Update README',
  author: { name: 'My AI Agent', email: 'agent@acme.dev' },
  files: [
    {
      path: 'README.md',
      action: 'upsert',
      content: Buffer.from('...').toString('base64'),
      encoding: 'base64',
    },
  ],
});

await mesa.bookmarks.move({
  repo: 'my-workspace',
  bookmark: 'feature/readme',
  change_id: change.id,
});

Use cases

Mesa is designed for high-throughput, machine-driven workflows where you need reliable versioning, low-latency reads and writes, and infinite scaling across many different repositories. It works wherever your agents run, whether in a sandbox or in-process. You can use it with a variety of tools and frameworks. Some common use cases that Mesa is optimized for:
  • Prompt-to-app builders
  • SWE agents
  • Agent infrastructure like sandboxes
  • Agent orchestrators
  • AI workflow builders

Benefits over traditional Git hosting

  • Our APIs and product surface area are designed from Day 1 to be used by Agents
  • Designed for high-volume automated workflows and large repo counts
  • Fine-grained API tokens for precise access control
  • Virtual filesystem for easy agent access

Pricing

See our pricing page for more details.

FAQ

No. You can use Mesa entirely through the SDK and REST API without ever running a Git command. Mesa handles versioning, branching, and history behind the scenes. If you choose to instead use Mesa as a standard Git server, it is fully compatible with standard Git clients over HTTPS.
Yes. Mesa supports clone, fetch, push, and branch operations over HTTPS using any Git client. Authenticate with your API key as the password:
git clone https://t:<API_KEY>@api.mesa.dev/<org>/<repo>.git
See the Git Server docs for details.
GitHub is built for human developers collaborating through pull requests. Mesa is built for machines. Our APIs, virtual filesystem, and versioning model are designed for high-throughput automated workflows where thousands of ephemeral agents read and write concurrently. Mesa also supports more ergonomic checkpoint-style versioning that doesn’t require the ceremony of Git, making it easier to use in agentic applications.
Mesa offers official SDKs for TypeScript, Python, and Rust. The REST API can be called from any language. Mesa works with agent frameworks like Vercel AI SDK, Langchain, and Mastra, and integrates with sandbox providers like Daytona and E2B.
Changes are Mesa’s core versioning primitive — similar to Git commits. Each change captures a snapshot of edits with a message and author. Bookmarks are lightweight pointers to changes — similar to Git branches. Together they support everything from simple linear checkpoints to full branching and merging workflows. See Versioning for more.
The FUSE-based virtual filesystem supports macOS (via macFUSE) and Linux (via FUSE3). For environments where FUSE isn’t available, the TypeScript SDK includes an app-level virtual filesystem that works anywhere Node.js runs. See Virtual Filesystem for details.
Automatic GitHub sync is coming soon. You can already push and pull between Mesa and GitHub using standard Git commands since Mesa is fully Git-compatible. See GitHub Sync for the latest status.
Mesa supports custom on-prem deployments for enterprise customers. By default, Mesa runs as a hosted service at app.mesa.dev. If you’re interested in on-prem deployment, reach out to us over email at founders@mesa.dev.