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
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.

/

Set up Sprites for Claude Code

superfly/sprites-claude-plugin

1

Add the marketplace and install the plugin

/plugin marketplace add superfly/sprites-claude-plugin
2

Install it

/plugin install sprites@sprites
3

Reload so Claude picks up the new tools

/reload-plugins
4

Authorize the connector

/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.
✓

Check the integration

/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

Set up Sprites for Cursor

superfly/sprites-cursor-plugin

1

Install the Sprites plugin from the Cursor Marketplace

Cursor prompts you to authorize with Sprites over OAuth on first use.
2
Or wire up the MCP server by hand
~/.cursor/mcp.json
```
{
  "mcpServers": {
    "sprites": {
      "url": "https://sprites.dev/mcp"
    }
  }
}
```
Drop this in ~/.cursor/mcp.json for every project, or .cursor/mcp.json for just this one.
✓

Ask the agent to prove it's connected

List my sprites.

Set up Sprites for OpenCode

superfly/sprites-opencode-plugin

1
Add the plugin to your OpenCode config
opencode.json
```
{
  "$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

Complete browser OAuth

/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.
✓

Ask OpenCode to prove it's connected

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 Any MCP client

superfly/sprites-mcp

1
Add a remote server entry
mcp.json
```
{
  "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.

If your client only speaks stdio, bridge it

mcp.json

{
  "mcpServers": {
    "sprites": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://sprites.dev/mcp"]
    }
  }
}

mcp-remote handles the OAuth flow on the client's behalf.

3

Authorize in the browser on first use
✓

Ask your agent to prove it's connected

List my sprites.

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

1

Install from PyPI

pip install sprites-py
2

Point it at your Sprites account

export SPRITES_TOKEN='...'

Create a token from the Sprites dashboard.

Build with Elixir

superfly/sprites-ex

1
Add the dependency
mix.exs
```
{:sprites, "~> 0.2"}
```
2

Fetch it

mix deps.get
3

Point it at your Sprites account

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

These products ship with Sprites support. Nothing to install, nothing to configure.

Use Sprites with TanStack AI

tanstack.com

Sprites as a sandbox provider for TanStack AI agents.

Read the setup guide

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
Codex	MCP Skills	Browser OAuth	superfly/sprites-codex-plugin
Cursor	MCP Skills	Browser OAuth	superfly/sprites-cursor-plugin
Antigravity	MCP Skills Commands Hooks	Browser OAuth	superfly/sprites-antigravity-plugin
Grok Build	MCP Skills	Browser OAuth	superfly/sprites-grok-plugin
Cortex Code	MCP Skills Commands Hooks	Browser OAuth	superfly/sprites-cortex-plugin
DeepSeek Harness	MCP Skills	Browser OAuth	superfly/sprites-deepseek-plugin
OpenCode	MCP Skills Commands Hooks	Browser OAuth	superfly/sprites-opencode-plugin
Pi	SDK Skills	API token	superfly/pi-sprites
VS Code	Filesystem	API token	superfly/sprites-vscode-ext
Any MCP client	MCP	Browser OAuth	superfly/sprites-mcp
Agent Plugins v1	MCP Skills	Browser OAuth	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.

Your agent wants to run the code it wrote.

Pick your agent and go!

Which agent are you using?

Set up Sprites for Claude Code

Set up Sprites for Codex

Set up Sprites for Cursor

Set up Sprites for Antigravity

Set up Sprites for Grok Build

Set up Sprites for Cortex Code

Set up Sprites for DeepSeek Harness

Set up Sprites for OpenCode

Set up Sprites for Pi

Set up Sprites for VS Code

Set up Sprites for Any MCP client

Set up Sprites for Agent Plugins v1

Underneath, it's a whole computer.

The SDKs, and the API they all sit on.

Which language are you building in?

Build with Python

Build with JavaScript

Build with Go

Build with Elixir

Build with Google ADK

Build with OpenAI Agents SDK

Build with OpenRouter Agent SDK

If setting anything up feels too much like work

Built into the platforms you already use

Use Sprites with TanStack AI

Use Sprites with Claude Managed Agents

Straight to the source.

Frequently asked questions

Pick your agent and go!

Which agent are you using?

Set up Sprites for Claude Code

Set up Sprites for Codex

Set up Sprites for Cursor

Set up Sprites for Antigravity

Set up Sprites for Grok Build

Set up Sprites for Cortex Code

Set up Sprites for DeepSeek Harness

Set up Sprites for OpenCode

π Set up Sprites for Pi

Set up Sprites for VS Code

Set up Sprites for Any MCP client

Set up Sprites for Agent Plugins v1

Underneath, it's a whole computer.

The SDKs, and the API they all sit on.

Which language are you building in?

Build with Python

Build with JavaScript

Build with Go

Build with Elixir

Build with Google ADK

Build with OpenAI Agents SDK

Build with OpenRouter Agent SDK

If setting anything up feels too much like work

Built into the platforms you already use

Use Sprites with TanStack AI

Use Sprites with Claude Managed Agents

Straight to the source.

Frequently asked questions

Set up Sprites for Pi