---
title: "Run agent-generated code on Fly.io Sprites"
description: "Your agent writes code and then wants to execute it. A Fly.io Sprite is a Linux computer you hand it instead: its own kernel, a disk that survives between runs, and an undo button for when the agent gets it wrong."
---

# Your agent wants to run the code it wrote.

There's a plugin for that.

At some point in any session your agent stops handing you scripts to review and starts executing them itself. It would be pretty useless if it didn't. That's also the point where your laptop stops being a sensible place to keep working.

Use a Sprite instead. We've (probably) already built an integration for your agent, so it's easy. Just follow the steps for your agent and immediately forget what it feels like to fear what your agent is doing when you're not watching.

Works with

- Claude Code
- Cursor
- Codex
- Antigravity
- Herdr
- Google ADK
- OpenAI Agents SDK
- OpenRouter Agent SDK
- TanStack AI
- Claude Managed Agents

## Pick your agent and go!

### Which agent are you using?

Pick one and follow the steps below.

/

Nothing matches that. Any MCP client can still point straight at the hosted server.

### Set up Sprites for Claude Code

[superfly/sprites-claude-plugin](https://github.com/superfly/sprites-claude-plugin)

1. 1
   Add the marketplace and install the plugin
   
   `/plugin marketplace add superfly/sprites-claude-plugin`
   
   ```
   /plugin marketplace add superfly/sprites-claude-plugin
   ```
2. 2
   Install it
   
   `/plugin install sprites@sprites`
   
   ```
   /plugin install sprites@sprites
   ```
3. 3
   Reload so Claude picks up the new tools
   
   `/reload-plugins`
   
   ```
   /reload-plugins
   ```
4. 4
   Authorize the connector
   
   `/mcp`
   
   ```
   /mcp
   ```
   
   Pick the plugin-provided sprites server and complete browser OAuth for the Fly.io org you want. Restricted access with a name prefix such as mcp- is the safer default.
5. ✓
   Check the integration
   
   `/sprites:status`
   
   ```
   /sprites:status
   ```
   
   An empty Sprite list means you're authenticated and working. /sprites:smoke runs the full list → create → exec → cleanup pass.

Prefer the bare MCP server, without the plugin's skills and hooks?

`claude mcp add --transport http sprites https://sprites.dev/mcp`

```
claude mcp add --transport http sprites https://sprites.dev/mcp
```

### Set up Sprites for Codex

[superfly/sprites-codex-plugin](https://github.com/superfly/sprites-codex-plugin)

1. 1
   Install the Sprites plugin from the Codex plugin marketplace
   
   Codex distributes this one through its own marketplace UI, so there's no install one-liner to copy.
2. 2
   Or add this repository as a marketplace from a local checkout
   
   `codex plugin marketplace add .`
   
   ```
   codex plugin marketplace add .
   ```
   
   Then restart Codex, open the plugin directory, choose the Sprites marketplace, and install Sprites.
3. 3
   Authenticate when Codex prompts you
   
   The plugin talks to the hosted MCP server at https://sprites.dev/mcp.
4. ✓
   Ask Codex to prove it's connected
   
   `List my sprites.`
   
   ```
   List my sprites.
   ```
   
   An empty list is a successful, authenticated response.

### Set up Sprites for Cursor

[superfly/sprites-cursor-plugin](https://github.com/superfly/sprites-cursor-plugin)

1. 1
   Install the Sprites plugin from the Cursor Marketplace
   
   Cursor prompts you to authorize with Sprites over OAuth on first use.
2. 2
   Or wire up the MCP server by hand
   
   ~/.cursor/mcp.json
   
   ```
   {
     "mcpServers": {
       "sprites": {
         "url": "https://sprites.dev/mcp"
       }
     }
   }
   ```
   
   ```
   {
     "mcpServers": {
       "sprites": {
         "url": "https://sprites.dev/mcp"
       }
     }
   }
   ```
   
   Drop this in ~/.cursor/mcp.json for every project, or .cursor/mcp.json for just this one.
3. ✓
   Ask the agent to prove it's connected
   
   `List my sprites.`
   
   ```
   List my sprites.
   ```

### Set up Sprites for Antigravity

[superfly/sprites-antigravity-plugin](https://github.com/superfly/sprites-antigravity-plugin)

1. 1
   Install straight from the repository
   
   `agy plugin install https://github.com/superfly/sprites-antigravity-plugin`
   
   ```
   agy plugin install https://github.com/superfly/sprites-antigravity-plugin
   ```
2. 2
   Authenticate the sprites server
   
   `/mcp`
   
   ```
   /mcp
   ```
   
   Use restricted access unless your workflow genuinely needs broader organization control.
3. ✓
   List what you've got
   
   `/sprites:list`
   
   ```
   /sprites:list
   ```
   
   The plugin also ships /sprites:new, /sprites:run, /sprites:checkpoint, /sprites:service, and /sprites:cleanup.

### Set up Sprites for Grok Build

[superfly/sprites-grok-plugin](https://github.com/superfly/sprites-grok-plugin)

1. 1
   Install the plugin
   
   `grok plugin install superfly/sprites-grok-plugin --trust`
   
   ```
   grok plugin install superfly/sprites-grok-plugin --trust
   ```
2. 2
   Enable it
   
   `grok plugin enable sprites`
   
   ```
   grok plugin enable sprites
   ```
3. 3
   Reload plugins, or restart Grok
   
   `/plugins`
   
   ```
   /plugins
   ```
   
   Then press r to reload.
4. 4
   Complete browser OAuth
   
   The consent screen defaults to the restricted mcp- name prefix. Full access allows bare names but grants unrestricted access to every sprite in the org.
5. ✓
   Run the status check
   
   `/sprites-status`
   
   ```
   /sprites-status
   ```
   
   Empty list means you're authenticated. /sprites-smoke does the full list → create → exec → confirm-before-destroy pass, and grok mcp doctor sprites diagnoses a bad install.

### Set up Sprites for Cortex Code

[superfly/sprites-cortex-plugin](https://github.com/superfly/sprites-cortex-plugin)

1. 1
   Install from GitHub
   
   `cortex plugin install superfly/sprites-cortex-plugin`
   
   ```
   cortex plugin install superfly/sprites-cortex-plugin
   ```
2. 2
   Enable the plugin
   
   `cortex plugin enable sprites`
   
   ```
   cortex plugin enable sprites
   ```
3. 3
   Reload inside your session, or restart Cortex Code
   
   `/plugin reload`
   
   ```
   /plugin reload
   ```
4. 4
   Authorize Sprites when requested
   
   `/mcp`
   
   ```
   /mcp
   ```
   
   Complete browser OAuth and select the intended Fly.io organization. No Sprites CLI or pasted API token is required.
5. ✓
   Check the connection
   
   `/sprites-status`
   
   ```
   /sprites-status
   ```
   
   An empty Sprite list still means authentication succeeded.

The plugin includes skills, commands, safety hooks, and a runner for long builds and tests. It does not copy Snowflake credentials or sessions into Sprites.

### Set up Sprites for DeepSeek Harness

[superfly/sprites-deepseek-plugin](https://github.com/superfly/sprites-deepseek-plugin)

1. 1
   Add the plugin to your profile
   
   `npx @deepseek-ai/dsh plugin --profile web add github:superfly/sprites-deepseek-plugin`
   
   ```
   npx @deepseek-ai/dsh plugin --profile web add github:superfly/sprites-deepseek-plugin
   ```
   
   Swap web for whichever profile you actually use.
2. 2
   Start that profile
   
   `npx @deepseek-ai/dsh --profile web`
   
   ```
   npx @deepseek-ai/dsh --profile web
   ```
3. 3
   Complete browser OAuth and pick your Fly.io organization
   
   Restart Harness once if the first tool sync timed out while you were authorizing.
4. ✓
   Confirm the layer loaded
   
   `npx @deepseek-ai/dsh --profile web --dump-config`
   
   ```
   npx @deepseek-ai/dsh --profile web --dump-config
   ```
   
   Output should include the dsh-sprites-plugin layer, sprites-mcp, and sprites-skill-filesystem.

### Set up Sprites for OpenCode

[superfly/sprites-opencode-plugin](https://github.com/superfly/sprites-opencode-plugin)

1. 1
   Add the plugin to your OpenCode config
   
   opencode.json
   
   ```
   {
     "$schema": "https://opencode.ai/config.json",
     "plugin": ["@flydotio/sprites-opencode-plugin"]
   }
   ```
   
   ```
   {
     "$schema": "https://opencode.ai/config.json",
     "plugin": ["@flydotio/sprites-opencode-plugin"]
   }
   ```
   
   OpenCode 1.18.23 or newer. Plugins install automatically with Bun at startup, so restart OpenCode after saving. Until the package lands on npm, clone the repository and use an absolute file:///path/to/sprites-opencode-plugin entry instead.
2. 2
   Complete browser OAuth
   
   `/sprites-status`
   
   ```
   /sprites-status
   ```
   
   The first Sprites request starts OpenCode's browser OAuth flow. Pick the Fly.io org you want. If no browser opens, run opencode mcp auth sprites and retry.
3. ✓
   Ask OpenCode to prove it's connected
   
   `List my sprites.`
   
   ```
   List my sprites.
   ```
   
   An empty list is a successful, authenticated response. /sprites-smoke walks the full list → create → exec pass, and opencode mcp debug sprites diagnoses a bad connection.

### Set up Sprites for OpenClaw

[superfly/openclaw-sprites](https://github.com/superfly/openclaw-sprites)

1. 1
   Check the requirements
   
   OpenClaw 2026.8.1 or newer and a Sprites API token are required. The Sprites CLI is not.
2. 2
   Install the plugin on the OpenClaw Gateway host
   
   `openclaw plugins install npm:openclaw-sprites`
   
   ```
   openclaw plugins install npm:openclaw-sprites
   ```
3. 3
   Store the Sprites token
   
   `openclaw secrets store set SPRITES_TOKEN --kind secret`
   
   ```
   openclaw secrets store set SPRITES_TOKEN --kind secret
   ```
   
   Paste the token into the hidden prompt so it is not written to openclaw.json or your shell history.
4. 4
   Connect the plugin to the protected secret
   
   `openclaw config set plugins.entries.sprites.config.token --ref-provider default --ref-source store --ref-id SPRITES_TOKEN`
   
   ```
   openclaw config set plugins.entries.sprites.config.token --ref-provider default --ref-source store --ref-id SPRITES_TOKEN
   ```
5. 5
   Sandbox every agent session
   
   `openclaw config set agents.defaults.sandbox.mode all`
   
   ```
   openclaw config set agents.defaults.sandbox.mode all
   ```
6. 6
   Use Sprites as the sandbox backend
   
   `openclaw config set agents.defaults.sandbox.backend sprites`
   
   ```
   openclaw config set agents.defaults.sandbox.backend sprites
   ```
7. 7
   Reuse one Sprite per agent
   
   `openclaw config set agents.defaults.sandbox.scope agent`
   
   ```
   openclaw config set agents.defaults.sandbox.scope agent
   ```
8. 8
   Allow tools to edit the copied workspace
   
   `openclaw config set agents.defaults.sandbox.workspaceAccess rw`
   
   ```
   openclaw config set agents.defaults.sandbox.workspaceAccess rw
   ```
9. 9
   Enable the plugin
   
   `openclaw plugins enable sprites`
   
   ```
   openclaw plugins enable sprites
   ```
10. 10
    Validate the configuration
    
    `openclaw config validate`
    
    ```
    openclaw config validate
    ```
11. 11
    Restart the Gateway
    
    `openclaw gateway restart`
    
    ```
    openclaw gateway restart
    ```
12. 12
    Trigger the first sandbox
    
    `Run `uname -a` and `python3 --version`, then tell me where those commands ran.`
    
    ```
    Run `uname -a` and `python3 --version`, then tell me where those commands ran.
    ```
    
    The Sprite is created on the first command or file-tool call.
13. ✓
    Check the Sprite
    
    `openclaw sprites status`
    
    ```
    openclaw sprites status
    ```
    
    No Sprite appears until an agent first uses a command or file tool. After that, look for an openclaw- name and its awake or asleep state.

The OpenClaw Gateway remains on its existing host. The workspace is copied into the Sprite initially and later edits are not automatically synced back. With this per-agent setup, files and installed packages persist across conversations.

### Set up Sprites for Pi

[superfly/pi-sprites](https://github.com/superfly/pi-sprites)

1. 1
   Install from GitHub
   
   `pi install git:github.com/superfly/pi-sprites`
   
   ```
   pi install git:github.com/superfly/pi-sprites
   ```
   
   Not on npm yet. Node.js 24 or later is required by the Sprites SDK.
2. 2
   Export a Sprites token into Pi's environment
   
   `export SPRITES_TOKEN='...'`
   
   ```
   export SPRITES_TOKEN='...'
   ```
   
   This integration authenticates with a token, not browser OAuth.
3. ✓
   Ask Pi to list your environments
   
   `List my sprites.`
   
   ```
   List my sprites.
   ```

### Set up Sprites for VS Code

[superfly/sprites-vscode-ext](https://github.com/superfly/sprites-vscode-ext)

1. 1
   Install the Sprites extension
2. 2
   Set your API token
   
   `Sprites: Set API Token`
   
   ```
   Sprites: Set API Token
   ```
   
   Run it from the Command Palette and paste your Sprites.dev API token.
3. 3
   Open a Sprite
   
   `Sprites: Open Sprite`
   
   ```
   Sprites: Open Sprite
   ```
   
   Its filesystem appears in your workspace, editable in place.
4. ✓
   Open a shell on the box
   
   `Sprites: Open Terminal`
   
   ```
   Sprites: Open Terminal
   ```
   
   Sprites: Create Sprite, Sprites: Delete Sprite, and a right-click Download to Local round out the command set.

### Set up Sprites for Herdr

[superfly/herdr-sprites-plugin](https://github.com/superfly/herdr-sprites-plugin)

1. 1
   Log in with the Sprite CLI
   
   `sprite login`
   
   ```
   sprite login
   ```
   
   Linux or macOS, Node.js 22 or newer, Git, and Herdr 0.9.0 or newer. The plugin drives the sprite CLI you just authenticated, so there is no token to paste.
2. 2
   Install the plugin from GitHub
   
   `herdr plugin install superfly/herdr-sprites-plugin`
   
   ```
   herdr plugin install superfly/herdr-sprites-plugin
   ```
3. 3
   Find the plugin's config directory
   
   `herdr plugin config-dir sprites`
   
   ```
   herdr plugin config-dir sprites
   ```
4. 4
   Choose an organization and an agent
   
   config.json
   
   ```
   {
     "org": "your-sprites-organization",
     "agent": "claude"
   }
   ```
   
   ```
   {
     "org": "your-sprites-organization",
     "agent": "claude"
   }
   ```
   
   Save it in the directory printed above. agent is claude, codex, or opencode. Add a command array to run a different agent or pass arguments; namePrefix defaults to herdr-.
5. 5
   Start an agent from a Git worktree
   
   `herdr plugin action invoke start-agent --plugin sprites`
   
   ```
   herdr plugin action invoke start-agent --plugin sprites
   ```
   
   Opens a split pane, creates a Sprite, uploads the worktree with its uncommitted edits, checkpoints it, and hands the terminal to the agent. start-claude, start-codex, and start-opencode pick a harness for one launch. Claude Code and Codex reuse your local login when one is available.
6. 6
   Optionally, bind it to a key
   
   config.toml
   
   ```
   [[keys.command]]
   key = "prefix+shift+s"
   type = "plugin_action"
   command = "sprites.start-agent"
   description = "start agent in a Sprite"
   ```
   
   ```
   [[keys.command]]
   key = "prefix+shift+s"
   type = "plugin_action"
   command = "sprites.start-agent"
   description = "start agent in a Sprite"
   ```
   
   Herdr's own config file, so the action runs from a prefix key instead of the CLI.
7. ✓
   Show the pane's Sprite and sessions
   
   `herdr plugin action invoke info --plugin sprites`
   
   ```
   herdr plugin action invoke info --plugin sprites
   ```
   
   Info reports the Sprite, its checkpoint, and the remote session list. reconnect reattaches a detached agent, pull brings its edits back into your worktree, and stop, checkpoint, restore, and destroy round out the set.

Git history, .env files, and credentials never leave your machine; the Sprite gets a fresh baseline repository. Pull rejects overlapping local edits before touching anything, and reconnect keeps remote files and authentication in place.

### Set up Sprites for Any MCP client

[superfly/sprites-mcp](https://github.com/superfly/sprites-mcp)

1. 1
   Add a remote server entry
   
   mcp.json
   
   ```
   {
     "mcpServers": {
       "sprites": {
         "url": "https://sprites.dev/mcp"
       }
     }
   }
   ```
   
   ```
   {
     "mcpServers": {
       "sprites": {
         "url": "https://sprites.dev/mcp"
       }
     }
   }
   ```
   
   Streamable HTTP over JSON-RPC 2.0, authenticated with OAuth 2.1 (sprites:read / sprites:write). Nothing runs locally.
2. 2
   If your client only speaks stdio, bridge it
   
   mcp.json
   
   ```
   {
     "mcpServers": {
       "sprites": {
         "command": "npx",
         "args": ["-y", "mcp-remote", "https://sprites.dev/mcp"]
       }
     }
   }
   ```
   
   ```
   {
     "mcpServers": {
       "sprites": {
         "command": "npx",
         "args": ["-y", "mcp-remote", "https://sprites.dev/mcp"]
       }
     }
   }
   ```
   
   mcp-remote handles the OAuth flow on the client's behalf.
3. 3
   Authorize in the browser on first use
4. ✓
   Ask your agent to prove it's connected
   
   `List my sprites.`
   
   ```
   List my sprites.
   ```

### Set up Sprites for Agent Plugins v1

[superfly/sprites-agent-plugin](https://github.com/superfly/sprites-agent-plugin)

1. 1
   Install the package with any Agent Plugins v1 client
   
   The client discovers plugin.json, the children of skills/, and mcp.json at fixed locations. Agent Plugins standardizes package contents, not the install UI, so follow your client's own local, Git, workspace, or marketplace flow.
2. 2
   Complete browser OAuth on first MCP use
   
   Restricted connector tokens may enforce a sprite-name prefix, creation cap, label, or expiry.
3. ✓
   Ask your agent to prove it's connected
   
   `List my sprites.`
   
   ```
   List my sprites.
   ```

Claude Code, Grok, and Antigravity are not on the current compatible-client list. Use their dedicated packages above, which also carry hooks the portable format has no equivalent for.

## Underneath, it's a whole computer.

**The boundary is the hardware.** A Sprite is a Firecracker microVM. It boots its own kernel, and that separation exists from the moment the Sprite does. The agent can install what it likes, misconfigure anything, and delete whatever. All of it can only happen inside the Sprite.

**You decide how it reaches the network.** Give a Sprite an allowlist of domains and it can only talk to those. Enforcement lands at the packet level rather than at the name lookup, so allowed domains resolve to addresses that get added to the filter, and everything else is dropped. Code that skips DNS and dials a raw IP doesn't get out either. The allowlist is set from outside the Sprite, so code running inside can read the policy it is under but never change it.

**The disk is still there tomorrow.** Come back a week later and that repo you cloned is still there. The deps are still installed and that half-finished branch is still checked out. Agents doing real work have to figure out which test is flaky and what they already tried. If you throw the disk away between sessions, they have to do all of it again before work starts (and nobody has time for that, not even robots).

**An undo button for the whole machine.** Checkpoint a state you like, and let the agent attempt a sketchy idea. If it breaks the environment, no big deal: just restore the whole filesystem back to the way it was before. You can restore from the same checkpoint as many times as you want.

**It sleeps when the agent stops typing.** An idle Sprite freezes, then suspends. The next command or HTTP request wakes it, with its filesystem exactly as it was. (This really suits agent work that comes in bursts with long gaps in between.)

Any language

## The SDKs, and the API they all sit on.

### Which language are you building in?

The same primitives the plugins are built on: create, exec, services, checkpoints, network policy.

### Build with Python

[superfly/sprites-py](https://github.com/superfly/sprites-py)

1. 1
   Install from PyPI
   
   `pip install sprites-py`
   
   ```
   pip install sprites-py
   ```
2. 2
   Point it at your Sprites account
   
   `export SPRITES_TOKEN='...'`
   
   ```
   export SPRITES_TOKEN='...'
   ```
   
   Create a token from the Sprites dashboard.

### Build with JavaScript

[superfly/sprites-js](https://github.com/superfly/sprites-js)

1. 1
   Install from npm
   
   `npm install @fly/sprites`
   
   ```
   npm install @fly/sprites
   ```
2. 2
   Point it at your Sprites account
   
   `export SPRITES_TOKEN='...'`
   
   ```
   export SPRITES_TOKEN='...'
   ```
   
   Create a token from the Sprites dashboard.

### Build with Go

[superfly/sprites-go](https://github.com/superfly/sprites-go)

1. 1
   Add the module
   
   `go get github.com/superfly/sprites-go`
   
   ```
   go get github.com/superfly/sprites-go
   ```
2. 2
   Point it at your Sprites account
   
   `export SPRITES_TOKEN='...'`
   
   ```
   export SPRITES_TOKEN='...'
   ```
   
   Create a token from the Sprites dashboard.

### Build with Elixir

[superfly/sprites-ex](https://github.com/superfly/sprites-ex)

1. 1
   Add the dependency
   
   mix.exs
   
   ```
   {:sprites, "~> 0.2"}
   ```
   
   ```
   {:sprites, "~> 0.2"}
   ```
2. 2
   Fetch it
   
   `mix deps.get`
   
   ```
   mix deps.get
   ```
3. 3
   Point it at your Sprites account
   
   `export SPRITES_TOKEN='...'`
   
   ```
   export SPRITES_TOKEN='...'
   ```
   
   Create a token from the Sprites dashboard.

### Build with Google ADK

[superfly/sprites-adk](https://github.com/superfly/sprites-adk)

1. 1
   Install from PyPI
   
   `pip install sprites-adk`
   
   ```
   pip install sprites-adk
   ```
2. 2
   Point it at your Sprites account
   
   `export SPRITES_TOKEN='...'`
   
   ```
   export SPRITES_TOKEN='...'
   ```
   
   Create a token from the Sprites dashboard.

### Build with OpenAI Agents SDK

[superfly/sprites-py](https://github.com/superfly/sprites-py)

1. 1
   Install from PyPI
   
   `pip install sprites-openai-agents`
   
   ```
   pip install sprites-openai-agents
   ```
2. 2
   Point it at your Sprites account
   
   `export SPRITES_API_TOKEN='...'`
   
   ```
   export SPRITES_API_TOKEN='...'
   ```
   
   This adapter reads SPRITES_API_TOKEN rather than SPRITES_TOKEN. The Agents SDK still wants OPENAI_API_KEY of its own.
3. 3
   Know what you're pinning
   
   The Agents SDK's sandbox APIs are beta, so each release of the adapter supports a deliberately narrow openai-agents version range. The source lives in sprites-py under integrations/openai-agents.

### Build with OpenRouter Agent SDK

[superfly/sprites-openrouter-sdk](https://github.com/superfly/sprites-openrouter-sdk)

1. 1
   Build from the repository
   
   Not on npm yet, and the API may change before the first stable release.
2. 2
   Point it at your Sprites account
   
   `export SPRITES_TOKEN='...'`
   
   ```
   export SPRITES_TOKEN='...'
   ```
   
   Create a token from the Sprites dashboard.

These are all just wrappers over the same REST API at `api.sprites.dev`. Creating and destroying Sprites, running commands, reading and writing files, running services, creating and restoring checkpoints, setting network policy. It's all just HTTP. The SDKs mean you don't have to do the plumbing, but you can build with whatever you like.

Don't see an SDK for your project's language? Someone's probably working on it.

Meanwhile, you can get going without one:

Shell

```
curl -X POST https://api.sprites.dev/v1/sprites \
  -H "authorization: Bearer $SPRITE_TOKEN" \
  -H "content-type: application/json" \
  -d '{"name": "agent-workspace"}'

curl -X POST "https://api.sprites.dev/v1/sprites/agent-workspace/exec?cmd=python&cmd=-c&cmd=print(2+2)" \
  -H "authorization: Bearer $SPRITE_TOKEN"
```

## If setting anything up feels too much like work

### Built into the platforms you already use

Products and platforms with a direct Sprites integration. No custom adapter to build — follow each product's setup flow.

### Use Sprites with TanStack AI

[tanstack.com](https://tanstack.com/ai/latest/docs/sandbox/providers#sprites)

Sprites as a sandbox provider for TanStack AI agents.

[Read the setup guide](https://tanstack.com/ai/latest/docs/sandbox/providers#sprites)

### Use Sprites with Claude Managed Agents

[docs.sprites.dev](https://docs.sprites.dev/integrations/claude-managed-agents/)

Anthropic runs the agent loop; each session's tool calls execute inside a Sprite you control.

[Read the setup guide](https://docs.sprites.dev/integrations/claude-managed-agents/)

### Use Sprites with Anthropic Connectors Directory

[claude.ai/directory/sprites](https://claude.ai/directory/sprites)

Let Claude manage your Sprites.

[Connect to Claude](https://claude.ai/directory/sprites)

### Use Sprites with QM

[github.com/yc-software/qm](https://github.com/yc-software/qm)

QM includes a built-in Sprites sandbox backend. Select Sprites and provide your Sprites API token.

[View QM on GitHub](https://github.com/yc-software/qm)

## Straight to the source.

Everything here is open source. Check out exactly what each integration does if you're into that kind of stuff.

| Integration | Ships | Auth | Repository |
| --- | --- | --- | --- |
| Claude Code | MCP Skills Hooks | Browser OAuth | [superfly/sprites-claude-plugin](https://github.com/superfly/sprites-claude-plugin) |
| Codex | MCP Skills | Browser OAuth | [superfly/sprites-codex-plugin](https://github.com/superfly/sprites-codex-plugin) |
| Cursor | MCP Skills | Browser OAuth | [superfly/sprites-cursor-plugin](https://github.com/superfly/sprites-cursor-plugin) |
| Antigravity | MCP Skills Commands Hooks | Browser OAuth | [superfly/sprites-antigravity-plugin](https://github.com/superfly/sprites-antigravity-plugin) |
| Grok Build | MCP Skills | Browser OAuth | [superfly/sprites-grok-plugin](https://github.com/superfly/sprites-grok-plugin) |
| Cortex Code | MCP Skills Commands Hooks | Browser OAuth | [superfly/sprites-cortex-plugin](https://github.com/superfly/sprites-cortex-plugin) |
| DeepSeek Harness | MCP Skills | Browser OAuth | [superfly/sprites-deepseek-plugin](https://github.com/superfly/sprites-deepseek-plugin) |
| OpenCode | MCP Skills Commands Hooks | Browser OAuth | [superfly/sprites-opencode-plugin](https://github.com/superfly/sprites-opencode-plugin) |
| OpenClaw | Sandbox Filesystem | API token | [superfly/openclaw-sprites](https://github.com/superfly/openclaw-sprites) |
| Pi | SDK Skills | API token | [superfly/pi-sprites](https://github.com/superfly/pi-sprites) |
| VS Code | Filesystem | API token | [superfly/sprites-vscode-ext](https://github.com/superfly/sprites-vscode-ext) |
| Herdr | Sandbox Commands Filesystem | Sprite CLI | [superfly/herdr-sprites-plugin](https://github.com/superfly/herdr-sprites-plugin) |
| Any MCP client | MCP | Browser OAuth | [superfly/sprites-mcp](https://github.com/superfly/sprites-mcp) |
| Agent Plugins v1 | MCP Skills | Browser OAuth | [superfly/sprites-agent-plugin](https://github.com/superfly/sprites-agent-plugin) |

## Frequently asked questions

Where should I run code that an AI agent generates? +

Not on your laptop, and not on the server running your production app. Run it somewhere isolated enough that a bad command only costs you that environment. A Fly.io Sprite is a hardware-isolated Linux computer built for exactly this: the agent gets a real machine to work on, and anything it breaks stays inside the boundary.

Is it safe to run agent-generated code on Fly.io Sprites? +

Every Fly.io Sprite is a Firecracker microVM with its own kernel, so the isolation is a hardware boundary rather than a shared kernel with namespaces on top. That boundary is always on and needs no configuration. On top of it you can restrict which hosts the Sprite reaches, which is worth doing when the code is genuinely untrusted.

Can I stop an agent on Fly.io Sprites from reaching the whole internet? +

Yes. Each Fly.io Sprite has a network policy that takes an allowlist of domains, and once you apply one, everything else is dropped. The useful detail is that the policy is set from outside the Sprite: code running inside can read the policy but has no route to widen it, so an agent cannot talk its way out of a restriction you applied. A Sprite starts permissive, so this is something you turn on rather than something you inherit.

Do Fly.io Sprites keep state between agent runs? +

Yes, and this is the main reason to use one. A Sprite's filesystem is durable, so the repository it cloned is still cloned, the dependencies it installed are still installed, and the notes it left itself are still on disk. The next run starts where the last one stopped instead of rebuilding an environment you already paid for once.

Can an agent roll back a change it got wrong on Fly.io? +

Yes. A Fly.io Sprite can checkpoint its whole filesystem, and restore puts it back. The workflow that makes failed agent runs cheap is to reach a good state, checkpoint it, let the agent attempt something risky, and restore if it goes badly. You can restore from the same checkpoint as many times as you like, which is what makes it worth using as a safety net rather than a backup.

Which agent frameworks work with Fly.io Sprites? +

There are adapters for the OpenAI Agents SDK and Google ADK, Sprites ships as a sandbox provider in TanStack AI, and Claude Managed Agents can run each session's tools inside a Sprite. Coding agents including Cursor, Codex, and Antigravity connect over MCP. Fly.io also publishes SDKs for JavaScript, Python, Go, and Elixir on top of the same REST API.

What happens to a Fly.io Sprite when the agent stops working? +

It sleeps. A Fly.io Sprite freezes when it goes idle and suspends shortly after, then wakes when the next command or HTTP request arrives, with its filesystem intact. An agent that works in bursts is not holding an always-on machine open between user messages.

What if my agent framework is not supported by Fly.io Sprites yet? +

The Sprites REST API works with anything that can make an HTTP request, which is usually enough to get moving today. It is also worth telling Fly.io what you are building with, because which frameworks get an official integration next is decided by what people actually ask for.