O novo Sprites.dev da Fly aborda sandboxes de desenvolvedor e sandboxes de API ao mesmo tempo

O novo Sprites.dev da Fly aborda sandboxes de desenvolvedor e sandboxes de API ao mesmo tempo

9 de janeiro de 2026

Novidade do Fly.io hoje: Sprites.dev. Aqui está a postagem do blog e a demonstração do YouTube. É um novo produto interessante que é bastante difícil de explicar – Fly o chama de “ambientes sandbox com estado com ponto de verificação e restauração”, mas vejo que ele atinge dois dos meus problemas favoritos atuais: um ambiente de desenvolvimento seguro para executar agentes de codificação e uma API para executar código não confiável em uma sandbox segura.

Divulgação: Fly patrocine alguns dos meus trabalhos. Eles não me pediram para escrever sobre Sprites e não tive acesso prévio antes do lançamento. Meu entusiasmo aqui é genuíno.

Sandboxes de desenvolvedor

Eu previ no início desta semana que “estamos diante de um desastre do Challenger no que diz respeito à segurança do agente de codificação” devido à forma aterrorizante como a maioria de nós está usando agentes de codificação como Claude Code e Codex CLI. Executando-os --dangerously-skip-permissions O modo (também conhecido como modo YOLO, onde o agente age sem buscar constantemente a aprovação primeiro) desbloqueia muito mais poder, mas também significa que um erro ou uma injeção de alerta maliciosa pode causar todos os tipos de danos ao seu sistema e dados.

A maneira segura de executar o modo YOLO é em uma sandbox robusta, onde a pior coisa que pode acontecer é a sandbox ficar bagunçada e você ter que jogá-la fora e comprar outra.

Esse é o primeiro problema que Sprites resolve:

curl https://sprites.dev/install.sh | bash

sprite login
sprite create my-dev-environment
sprite console -s my-dev-environment

Isso é tudo o que é necessário para conectar o SSH a um ambiente novo, rodando em um servidor de aproximadamente 8 GB de RAM e 8 CPUs. E… Claude Code e Codex e Gemini CLI e Python 3.13 e Node.js 22.20 e um monte de outras ferramentas já estão instaladas.

A primeira vez que você corre claude ele conecta você perfeitamente à sua conta existente na Anthropic. A VM Sprites é persistente, portanto, execuções futuras de sprite console -s irá levá-lo de volta para onde você estava antes.

… e configura automaticamente o encaminhamento de porta, para que você possa executar um servidor localhost em seu Sprite e acessá-lo de localhost:8080 em sua máquina.

Há também um comando que você pode executar para atribuir uma URL pública ao seu Sprite, para que qualquer outra pessoa possa acessá-lo se souber a URL secreta.

Armazenamento e pontos de verificação

Na postagem do blog, Kurt Mackey argumenta que sandboxes efêmeras e descartáveis ​​não são a melhor opção para agentes de codificação:

O que há de mais moderno em isolamento de agentes é uma sandbox somente leitura. Na Fly.io, vendemos essa história há anos e a chamamos: sandboxes efêmeras são obsoletas. Pare de matar suas sandboxes toda vez que usá-las. (…)

Se você forçar um agente a fazê-lo, ele contornará a conteinerização e funcionará. Mas você não está ajudando o agente de forma alguma fazendo isso. Eles não querem contêineres. Eles não querem “caixas de areia”. Eles querem computadores.

(…) com um computador real, Claude não precisa reconstruir todo o meu ambiente de desenvolvimento toda vez que pego um PR.

Cada Sprite obtém um sistema de arquivos adequado que persiste entre as sessões, mesmo quando o próprio Sprite é desligado após inatividade. Parece que eles estão fazendo alguns truques inteligentes no sistema de arquivos aqui. Estou ansioso para aprender mais sobre eles no futuro.

Existem algumas pistas na página inicial:

Você lê e grava em armazenamento NVMe rápido e conectado diretamente. Seus dados são então gravados em um armazenamento de objetos externo durável. (…)

Você não paga pelo espaço alocado no sistema de arquivos, apenas pelos blocos que você escreve. E é tudo compatível com TRIM, então sua conta diminui quando você exclui coisas.

O recurso realmente inteligente são os pontos de verificação. Você (ou seu agente de codificação) pode acionar um ponto de verificação que leva cerca de 300 ms. Isso captura todo o estado do disco e pode ser revertido posteriormente.

Para saber mais sobre como isso funciona, execute isto em um Sprite:

cat /.sprite/docs/agent-context.md

Aqui está a seção relevante:

## Checkpoints
- Point-in-time checkpoints and restores available
- Copy-on-write implementation for storage efficiency
- Last 5 checkpoints mounted at `/.sprite/checkpoints`
- Checkpoints capture only the writable overlay, not the base image

Ou execute isto para ver o --help para o comando usado para gerenciá-los:

sprite-env checkpoints --help

Que se parece com isto:

sprite-env checkpoints - Manage environment checkpoints

USAGE:
    sprite-env checkpoints  (options)

SUBCOMMANDS:
    list (--history )  List all checkpoints (optionally filter by history version)
    get                 Get checkpoint details (e.g., v0, v1, v2)
    create                  Create a new checkpoint (auto-versioned)
    restore             Restore from a checkpoint (e.g., v1)

NOTE:
    Checkpoints are versioned as v0, v1, v2, etc.
    Restore returns immediately and triggers an async restore that restarts the environment.
    The last 5 checkpoints are mounted at /.sprite/checkpoints for direct file access.

EXAMPLES:
    sprite-env checkpoints list
    sprite-env checkpoints list --history v1.2.3
    sprite-env checkpoints get v2
    sprite-env checkpoints create
    sprite-env checkpoints restore v1

Uso realmente inteligente de Claude Skills

Sou um grande fã de Skills, o mecanismo pelo qual Claude Code (e cada vez mais outros agentes também) podem receber recursos adicionais, descrevendo-os em arquivos Markdown em uma estrutura de diretório específica.

Em um design inteligente, Sprites usa habilidades pré-instaladas para ensinar Claude como o próprio Sprites funciona. Isso significa que você pode perguntar a Claude na máquina como fazer coisas como abrir portas e ele irá orientá-lo durante o processo.

Há todo tipo de coisa interessante no /.sprite pasta naquela máquina – pesquisar lá é uma ótima maneira de aprender mais sobre como Sprites funciona.

Uma API de sandbox

Também da minha postagem de previsões no início desta semana: “Finalmente vamos resolver o sandboxing”. Estou obcecado com este problema: quero poder executar códigos não confiáveis ​​com segurança, tanto em meus dispositivos pessoais quanto no contexto de serviços da Web que estou construindo para uso de outras pessoas.

Eu tenho tantas coisas Quero construir isso dependendo da capacidade de pegar código não confiável – de usuários ou de LLMs ou de LLMs conduzidos por usuários – e executar esse código em uma sandbox onde posso ter certeza de que o raio de explosão se algo der errado está firmemente contido.

Sprites oferece uma API JSON limpa para fazer exatamente isso, além de bibliotecas de cliente em Go e TypeScript e em breve Python e Elixir.

Desde o início rápido:

# Create a new sprite
curl -X PUT https://api.sprites.dev/v1/sprites/my-sprite \
-H "Authorization: Bearer $SPRITES_TOKEN"

# Execute a command
curl -X POST https://api.sprites.dev/v1/sprites/my-sprite/exec \
-H "Authorization: Bearer $SPRITES_TOKEN" \
-d '{"command": "echo hello"}'

Você também pode fazer checkpoint e rollback por meio da API, para que seu ambiente fique exatamente como você gosta, faça checkpoint, execute um monte de código não confiável e, em seguida, reverta para o ponto de verificação limpo quando terminar.

Gerenciar o acesso à rede é uma parte importante da manutenção de um bom sandbox. A API Sprites permite configurar políticas de acesso à rede usando uma lista de permissões/negações baseada em DNS como esta:

curl -X POST \
  "https://api.sprites.dev/v1/sprites/{name}/policy/network" \
  -H "Authorization: Bearer $SPRITES_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "rules": (
      {
        "action": "allow",
        "domain": "github.com"
      },
      {
        "action": "allow",
        "domain": "*.npmjs.org"
      }
    )
  }'

Faturamento escalonado até zero

Sprites têm escala zero incorporada à arquitetura. Eles adormecem após 30 segundos de inatividade, acordam rapidamente quando necessário e cobram apenas pelas horas de CPU, horas de RAM e GB-horas de armazenamento que você usa enquanto o Sprite está ativo.

A Fly estima que uma sessão de codificação intensiva de 4 horas custa cerca de 46 centavos e um aplicativo da web de baixo tráfego com 30 horas de ativação por mês por aproximadamente US$ 4.

(Calculo que um aplicativo da web que consome todas as 8 CPUs e todos os 8 GB de RAM 24 horas por dia, 7 dias por semana, por um mês custaria ((7 centavos * 8 * 24 * 30) + (4,375 centavos * 8 * 24 * 30)) / 100 = $ 655,2 por mês, portanto, não use-os necessariamente como sua solução de hospedagem na web principal para um aplicativo que absorve toda a CPU e RAM disponíveis!)

Dois dos meus problemas favoritos ao mesmo tempo

Eu estava esperançoso de que a Fly entraria no mercado de APIs sandbox amigáveis ​​ao desenvolvedor, especialmente considerando outros participantes de empresas como Cloudflare, Modal e E2B.

Eu não esperava que eles resolvessem o problema do sandbox do desenvolvedor ao mesmo tempo e com o mesmo produto!

Minha única preocupação aqui é que isso torne o produto em si um pouco mais difícil de explicar.

Já estou criando alguns protótipos de coisas adjacentes à sandbox que sempre quis construir, e os primeiros sinais são muito promissores. Escreverei mais sobre isso à medida que se transformarem em projetos úteis.