Sprites MCP server

Paste it into your assistant. It asks for the manifest, the server wiring and the skills, and for an honest account of what this record does not say. Read that second file first.

Draft an Agent Plugin (agent-plugins.org, specification 1.1.0) that wraps the
MCP server described below, so that somebody could install one thing and have
an assistant that knows when and how to use it.

An Agent Plugin is one installable unit: a `plugin.json` manifest, an
`mcp.json` that wires up the servers it needs, and a `skills/` directory
where each skill is a folder holding a `SKILL.md`. Hand back every file in
full, each under its own path, ready to save.

1. Write `plugin.json` with `$schema` exactly `https://agent-plugins.org/schemas/1.1.0/plugin.schema.json`. The name is
   1 to 64 characters of a-z, 0-9, `-` and `.`, alphanumeric at both ends, with
   no `--` and no `..` in it.

2. Write `mcp.json` wiring THIS server exactly as its record declares it. A
   remote keeps the URL and the transport type as written. A package keeps the
   registry, the identifier and the version as written. Do not invent a command,
   a port, a flag or an argument that is not in the record.

3. Every secret stays an input. No key, token, password or connection string
   belongs in either file. Declare what has to be supplied, name it, and say what
   it is for.

4. Do not invent tools. The record lists the tools it lists, and if it lists
   none then the honest plugin says the tool list was not published rather than
   guessing one from the description.

5. Skills are jobs, not tools. Write one skill per thing somebody would actually
   ask for, and inside each one say when to reach for this server, what a good
   result looks like, and what to do when it comes back empty. A skill per tool
   is a manual page with a different filename.

6. Say where it stops. Name what this plugin will not do — what it has no tool
   for, what needs a person, and what it must not be pointed at. A plugin with no
   stated edge reads as one with no edge.

7. Keep the author's own words for the description. If you would rather say it
   differently, say yours somewhere else and leave theirs where it is.

8. Record which version of the server you wrapped, and where the record came
   from, at the top of `plugin.json`'s description or in the readme. A plugin
   nobody can trace back to a version is one nobody can update.

Produce a second file alongside them, `LIMITS.md`, and treat it as the more
important of the two. The plugin is for whoever installs it. This is for
whoever has to decide whether installing it is a good idea, and that is
usually a different person who will never read the manifest.

It has three parts.

**What this is built from.** One paragraph: whose server it is, what the
record says it does, which version, and the fact that the record is all you
had. Say plainly that nobody ran it.

**What the record does not say.** One entry per gap. Whether the tool list was
published. What the server does with what it reads. What it costs. Whether it
writes anything anywhere. What credentials it will ask for and what those
credentials can reach. An unanswered question stays an unanswered question:
do not fill one in from the description or from what similar servers usually do.

**What a person has to check before trusting it.** The specific things
somebody should verify for themselves, in the order that would stop them
soonest if the answer is bad.

Write it in plain English, and do not soften it. A plugin drafted from a
directory record is a starting point to argue with, not something to install
into anything that matters.

The server record follows, exactly as the public index holds it. It is
everything I have: nobody has run this server, called a tool on it, or checked
that the address answers.

```json
{
  "authentication": {
    "required": true,
    "resourceMetadataUrl": "https://sprites.dev/.well-known/oauth-protected-resource",
    "schemes": [
      "bearer",
      "oauth2"
    ]
  },
  "capabilities": {
    "tools": {}
  },
  "description": "Create and control Sprites — persistent Linux machines that an agent can build, test, and run services in.",
  "documentationUrl": "https://fly.io/sprites/ecosystem",
  "iconUrl": "https://fly.io/phx/ui/images/favicon/android-chrome-512x512-51f9bf62189f55fd80478d031066724c.png?vsn=d",
  "icons": [
    {
      "mimeType": "image/png",
      "sizes": [
        "512x512"
      ],
      "src": "https://fly.io/phx/ui/images/favicon/android-chrome-512x512-51f9bf62189f55fd80478d031066724c.png?vsn=d"
    }
  ],
  "instructions": "Every request needs a bearer token; how to get one is at https://fly.io/auth.md. Tools other than list_sprites, create_sprite and destroy_sprite take a `sprite` parameter naming the Sprite to act in.",
  "name": "sprites",
  "protocolVersion": "2025-11-25",
  "remotes": [
    {
      "supportedProtocolVersions": [
        "2025-11-25"
      ],
      "type": "streamable-http",
      "url": "https://sprites.dev/mcp"
    }
  ],
  "serverInfo": {
    "name": "sprites",
    "title": "Fly.io Sprites",
    "version": "1.0.0"
  },
  "serverUrl": "https://sprites.dev/mcp",
  "title": "Fly.io Sprites",
  "tools": [
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "List Sprites"
      },
      "description": "List sprites for the authenticated organization.",
      "inputSchema": {
        "properties": {
          "continuation_token": {
            "type": "string"
          },
          "max_results": {
            "type": "integer"
          },
          "prefix": {
            "type": "string"
          }
        },
        "required": [],
        "type": "object"
      },
      "name": "list_sprites"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Create Sprite"
      },
      "description": "Create a new sprite in the authenticated organization.",
      "inputSchema": {
        "properties": {
          "name": {
            "type": "string"
          },
          "wait_for_capacity": {
            "type": "boolean"
          }
        },
        "required": [
          "name"
        ],
        "type": "object"
      },
      "name": "create_sprite"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Destroy Sprite"
      },
      "description": "Destroy a sprite in the authenticated organization.",
      "inputSchema": {
        "properties": {
          "name": {
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "type": "object"
      },
      "name": "destroy_sprite"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "Exec List"
      },
      "description": "List active exec sessions.",
      "inputSchema": {
        "properties": {
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite"
        ],
        "type": "object"
      },
      "name": "exec_list"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": true,
        "readOnlyHint": false,
        "title": "Exec"
      },
      "description": "Execute a command via simple HTTP POST (non-TTY only). Simpler alternative for exec for environments that can't handle websockets.",
      "inputSchema": {
        "properties": {
          "cmd": {
            "description": "Command to execute (can be repeated for command + args)",
            "type": "string"
          },
          "dir": {
            "description": "Working directory for the command",
            "type": "string"
          },
          "env": {
            "description": "Environment variables in `KEY=VALUE` format (can be repeated)",
            "type": "string"
          },
          "path": {
            "description": "Explicit path to executable (defaults to first `cmd` value or `bash`)",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "stdin": {
            "description": "Enable stdin from request body (default: `false`)",
            "type": "boolean"
          }
        },
        "required": [
          "sprite",
          "cmd"
        ],
        "type": "object"
      },
      "name": "exec"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Exec Kill"
      },
      "description": "Kill an exec session by session ID. Returns streaming NDJSON with kill progress.",
      "inputSchema": {
        "properties": {
          "session_id": {
            "description": "Session id",
            "type": "string"
          },
          "signal": {
            "description": "Signal to send (default: `SIGTERM`)",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "timeout": {
            "description": "Timeout waiting for process to exit (default: `10s`)",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "session_id"
        ],
        "type": "object"
      },
      "name": "exec_kill"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Checkpoint Create"
      },
      "description": "Create a new checkpoint of the current sprite state. Returns streaming NDJSON progress.",
      "inputSchema": {
        "properties": {
          "comment": {
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite"
        ],
        "type": "object"
      },
      "name": "checkpoint_create"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "Checkpoint List"
      },
      "description": "List all checkpoints.",
      "inputSchema": {
        "properties": {
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite"
        ],
        "type": "object"
      },
      "name": "checkpoint_list"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "Checkpoint Get"
      },
      "description": "Get details of a specific checkpoint.",
      "inputSchema": {
        "properties": {
          "checkpoint_id": {
            "description": "Checkpoint id",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "checkpoint_id"
        ],
        "type": "object"
      },
      "name": "checkpoint_get"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Checkpoint Restore"
      },
      "description": "Restore to a specific checkpoint. Returns streaming NDJSON progress.",
      "inputSchema": {
        "properties": {
          "checkpoint_id": {
            "description": "Checkpoint id",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "checkpoint_id"
        ],
        "type": "object"
      },
      "name": "checkpoint_restore"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "Policy Network Get"
      },
      "description": "Get the current network policy configuration.",
      "inputSchema": {
        "properties": {
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite"
        ],
        "type": "object"
      },
      "name": "policy_network_get"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Policy Network Update"
      },
      "description": "Update the network policy configuration.",
      "inputSchema": {
        "properties": {
          "rules": {
            "description": "List of network policy rules",
            "type": "array"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "rules"
        ],
        "type": "object"
      },
      "name": "policy_network_update"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "Service List"
      },
      "description": "List all configured services and their current state.",
      "inputSchema": {
        "properties": {
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite"
        ],
        "type": "object"
      },
      "name": "service_list"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "Service Get"
      },
      "description": "Get details of a specific service.",
      "inputSchema": {
        "properties": {
          "service_name": {
            "description": "Service name",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "service_name"
        ],
        "type": "object"
      },
      "name": "service_get"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Service Create"
      },
      "description": "Create or update a service definition.",
      "inputSchema": {
        "properties": {
          "args": {
            "description": "Command arguments",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "cmd": {
            "description": "Command to execute",
            "type": "string"
          },
          "duration": {
            "description": "Time to monitor logs after starting (default: `5s`)",
            "type": "string"
          },
          "http_port": {
            "description": "HTTP port for proxy routing",
            "type": "integer"
          },
          "needs": {
            "description": "Service dependencies (started first)",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "service_name": {
            "description": "Service name",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "service_name",
          "cmd",
          "args",
          "needs"
        ],
        "type": "object"
      },
      "name": "service_create"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": true,
        "readOnlyHint": false,
        "title": "Service Start"
      },
      "description": "Start a service. Returns streaming NDJSON with stdout/stderr.",
      "inputSchema": {
        "properties": {
          "duration": {
            "description": "Time to monitor logs after starting (default: `5s`)",
            "type": "string"
          },
          "service_name": {
            "description": "Service name",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "service_name"
        ],
        "type": "object"
      },
      "name": "service_start"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "Service Stop"
      },
      "description": "Stop a running service. Returns streaming NDJSON with service stop progress.",
      "inputSchema": {
        "properties": {
          "service_name": {
            "description": "Service name",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "timeout": {
            "description": "Timeout waiting for service to stop (default: `10s`)",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "service_name"
        ],
        "type": "object"
      },
      "name": "service_stop"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "Service Logs"
      },
      "description": "Stream logs for a service.",
      "inputSchema": {
        "properties": {
          "duration": {
            "description": "Time to follow new logs (default: `0`, no follow)",
            "type": "string"
          },
          "lines": {
            "description": "Number of lines to return from log buffer (default: all)",
            "type": "integer"
          },
          "service_name": {
            "description": "Service name",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "service_name"
        ],
        "type": "object"
      },
      "name": "service_logs"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "File Read"
      },
      "description": "Read file contents from the sprite filesystem. Returns raw file bytes.",
      "inputSchema": {
        "properties": {
          "encoding": {
            "default": "utf8",
            "description": "Content encoding for the file read. Use utf8 (the default) for an MCP embedded text resource, or base64 for an MCP embedded binary resource with a base64 blob.",
            "enum": [
              "utf8",
              "base64"
            ],
            "type": "string"
          },
          "path": {
            "description": "Path to the file to read",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "workingDir": {
            "description": "Working directory for resolving relative paths",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "path",
          "workingDir"
        ],
        "type": "object"
      },
      "name": "file_read"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "File Write"
      },
      "description": "Write file contents to the sprite filesystem. Request body contains raw file bytes.",
      "inputSchema": {
        "properties": {
          "content": {
            "description": "For utf8, the literal text to write. For base64, RFC 4648 base64-encoded bytes without a data URL prefix; the server decodes them before writing.",
            "type": "string"
          },
          "encoding": {
            "default": "utf8",
            "description": "Content encoding for the file write. Use utf8 (the default) for literal text, or base64 when content contains RFC 4648 base64-encoded bytes without a data URL prefix.",
            "enum": [
              "utf8",
              "base64"
            ],
            "type": "string"
          },
          "mkdir": {
            "description": "Create parent directories if they don't exist",
            "type": "boolean"
          },
          "mode": {
            "description": "File permissions in octal (e.g., '0644')",
            "type": "string"
          },
          "path": {
            "description": "Path to the file to write",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "workingDir": {
            "description": "Working directory for resolving relative paths",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "path",
          "workingDir",
          "content"
        ],
        "type": "object"
      },
      "name": "file_write"
    },
    {
      "annotations": {
        "destructiveHint": false,
        "openWorldHint": false,
        "readOnlyHint": true,
        "title": "File List"
      },
      "description": "List directory contents.",
      "inputSchema": {
        "properties": {
          "path": {
            "description": "Path to the directory to list",
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "workingDir": {
            "description": "Working directory for resolving relative paths",
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "path",
          "workingDir"
        ],
        "type": "object"
      },
      "name": "file_list"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "File Delete"
      },
      "description": "Delete a file or directory.",
      "inputSchema": {
        "properties": {
          "asRoot": {
            "type": "boolean"
          },
          "path": {
            "type": "string"
          },
          "recursive": {
            "type": "boolean"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "workingDir": {
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "path",
          "workingDir",
          "recursive",
          "asRoot"
        ],
        "type": "object"
      },
      "name": "file_delete"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "File Rename"
      },
      "description": "Rename or move a file or directory.",
      "inputSchema": {
        "properties": {
          "asRoot": {
            "type": "boolean"
          },
          "dest": {
            "type": "string"
          },
          "source": {
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "workingDir": {
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "source",
          "dest",
          "workingDir",
          "asRoot"
        ],
        "type": "object"
      },
      "name": "file_rename"
    },
    {
      "annotations": {
        "destructiveHint": true,
        "openWorldHint": false,
        "readOnlyHint": false,
        "title": "File Copy"
      },
      "description": "Copy a file or directory.",
      "inputSchema": {
        "properties": {
          "asRoot": {
            "type": "boolean"
          },
          "dest": {
            "type": "string"
          },
          "preserveAttrs": {
            "type": "boolean"
          },
          "recursive": {
            "type": "boolean"
          },
          "source": {
            "type": "string"
          },
          "sprite": {
            "description": "Name of the sprite to target.",
            "type": "string"
          },
          "workingDir": {
            "type": "string"
          }
        },
        "required": [
          "sprite",
          "source",
          "dest",
          "workingDir",
          "recursive",
          "preserveAttrs",
          "asRoot"
        ],
        "type": "object"
      },
      "name": "file_copy"
    }
  ],
  "transport": {
    "endpoint": "https://sprites.dev/mcp",
    "type": "streamable-http"
  },
  "version": "1.0.0",
  "websiteUrl": "https://fly.io/sprites"
}
```

The server is listed as "Sprites MCP server".