Problem Addressed

Fly.io

Research Date: 2026-02-23 Source URL: https://fly.io/ GitHub Repository: https://github.com/superfly (organization) Version at Research: flyctl v0.4.14 (latest at research date) License: Apache-2.0 (open-source components: flyctl, fly-go) / Proprietary (platform)

Overview

Fly.io is a developer-focused cloud platform that runs application code inside Firecracker microVMs, providing hardware-level isolation, sub-second startup times, and global anycast networking across 18 regions. It positions itself as compute that "gets out of the way" — deploy any container or binary with fly launch, pay per-second for actual usage, and get globally-distributed infrastructure without managing Kubernetes or Terraform. In 2025-2026 Fly.io extended the platform with Sprites (sprites.dev), persistent stateful sandboxes purpose-built for running AI coding agents like Claude Code at scale.

Problem Addressed

Key Statistics

Key Features

Fly Machines (Core Compute)

• Firecracker-based microVMs; hardware-isolated via KVM
• Sub-second start/stop; suitable for handling individual HTTP requests
• Full lifecycle control via REST API (https://api.machines.dev) or flyctl
• Configure CPU (shared or dedicated), RAM, region, and environment variables per Machine
• Autoscale to tens of thousands of instances programmatically
• Per-second billing — machines stopped when idle cost nothing

Sprites (Agent Sandboxes)

• Persistent, stateful Linux environments backed by Firecracker microVMs
• Designed for AI coding agents (Claude Code, reasoning LLMs) and untrusted code execution
• Checkpoint & restore: snapshot full VM state; roll back if anything breaks
• Fast startup: 1–12 seconds; auto-shutoff when idle
• HTTP endpoint per Sprite for webhooks, serving APIs, and public sharing
• CLI (sprite), REST API (api.sprites.dev), TypeScript SDK (@fly/sprites), Go SDK
• Non-Docker storage stack with NVMe for durability and performance

Global Networking (BGP Anycast + WireGuard)

• BGP anycast: IPs broadcast from all datacenters; connections routed to closest VM
• fly-proxy: Rust-based proxy on every server handles TLS termination, backhaul, routing
• WireGuard backhaul between datacenters; connections traverse minimal additional latency
• 6PN (IPv6 Private Network): automatic encrypted mesh across all apps in an org
• .internal DNS: apps resolve each other by name without public exposure
• Flycast: internal load balancing and traffic steering for multi-region topologies
• Connect external nodes (laptops, other clouds) to the private network via fly wireguard create

Persistent Storage

• Fly Volumes: regional NVMe-backed persistent disks; attach to Machines for stateful apps
• Fly Postgres (Managed): HA Postgres with automatic failover, daily backups, replication
• Fly Postgres (Unmanaged): self-managed Postgres running as a Fly app on volumes
• Object storage available through Tigris (S3-compatible, globally distributed)
• Sprite storage: hot NVMe cache ($0.000683/GB-hour) + durable bucket storage ($0.000027/GB-hour)

Model Context Protocol (MCP)

• Fly.io has first-class MCP documentation and tooling at fly.io/docs/mcp/
• fly mcp launch: one-command deployment of npx, uv, go run, or Docker stdio MCP servers
• Fly MCP server (fly-mcp): community Go server to manage Fly.io infrastructure via Claude
• Remote MCP servers on Fly.io connect to Claude via mcp_servers array in the Messages API
• MCP servers run as single-Machine apps (non-HA) to preserve stateful protocol sessions
• Transport options: stdio (local), SSE, and Streamable HTTP (for remote Fly-hosted servers)

Developer Experience

• fly launch: auto-detects frameworks, generates fly.toml, builds image, deploys
• fly deploy: rebuild and redeploy with zero downtime rolling updates
• fly ssh console: SSH into any running Machine
• fly logs, fly status, fly scale: observability and scaling commands
• CI/CD integration supported; deploy tokens scoped per environment
• SOC2 Type 2 attested; Single Sign-On for enterprise

Technical Architecture

User Traffic
     │
     ▼
BGP Anycast (18 regions)
     │
     ▼
fly-proxy (Rust, on every server)
  ├─ TLS termination
  ├─ App/Machine routing
  └─ WireGuard backhaul to nearest Machine
          │
          ▼
     Firecracker microVM
     ├─ KVM hardware isolation
     ├─ Dedicated CPU cores (best-effort)
     ├─ 32–256 GB RAM host servers
     ├─ Fly Volume (NVMe persistent storage)
     └─ 6PN (WireGuard IPv6 private mesh)
              │
              ▼
         Other apps / Postgres
         via .internal DNS

Key components:

• fly-proxy: Rust-based, runs on every physical server; handles all ingress/egress
• Firecracker: AWS-developed open-source VMM; provides microVM isolation via KVM
• 6PN: Per-organization WireGuard mesh; auto-provisioned, zero configuration
• flyctl / fly-go: Go-based CLI and SDK; open source on GitHub (superfly/flyctl, superfly/fly-go)
• Machines API: REST API at api.machines.dev; OpenAPI 3.0 spec at docs.machines.dev
• Sprites API: REST API at api.sprites.dev; separate product built on same Fly infrastructure

Installation & Usage

# Install flyctl (macOS)
brew install flyctl

# Install flyctl (Linux/Windows)
curl -L https://fly.io/install.sh | sh

# Install Sprites CLI
curl https://sprites.dev/install.sh | bash

# Authenticate
fly auth login
sprite login

# Deploy any app
fly launch       # auto-detect, configure, and deploy
fly deploy       # redeploy on changes

# Fly Machines API - create a machine
export FLY_API_TOKEN=$(fly tokens deploy)
export FLY_API_HOSTNAME="https://api.machines.dev"

curl -X POST "${FLY_API_HOSTNAME}/v1/apps/my-app/machines" \
  -H "Authorization: Bearer ${FLY_API_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "config": {
      "image": "registry.fly.io/my-app:latest",
      "guest": { "cpu_kind": "shared", "cpus": 1, "memory_mb": 256 }
    }
  }'

# Sprites - create and use a sandbox
sprite create my-agent-sandbox
sprite exec -s my-agent-sandbox -- python agent.py
sprite console -s my-agent-sandbox   # interactive shell

# Fly MCP - deploy a stdio MCP server
fly mcp launch --image my-mcp-server:latest

# Private networking - connect from local machine
fly wireguard create personal my-peer > peer.conf
# Import peer.conf into any WireGuard client

Relevance to Claude Code Development

Applications

• Run Claude Code as an agent on Sprites: Sprites are explicitly designed for AI coding agents like Claude Code; each gets an isolated VM with persistent filesystem, checkpointing, and rollback
• Deploy MCP servers: Host any MCP server on Fly.io with fly mcp launch; connect Claude to it via the Messages API mcp_servers field
• Safe code execution sandbox: Execute AI-generated or user-provided code in hardware-isolated Sprite VMs — prevents prompt injection from compromising host systems
• Deploy skills/agent backends globally: Fly.io's 18-region deployment means Claude-powered APIs respond with sub-100ms latency to users worldwide
• Persistent agent state: Use Fly Volumes or Sprite storage for agents that need to remember context across sessions, build SQLite databases, or maintain project state
• Orchestrate multi-agent swarms: Machines API allows programmatic creation/destruction of thousands of ephemeral VMs — each agent gets its own isolated compute

Patterns Worth Adopting

• Checkpoint/restore for reproducibility: Sprite checkpoints enable saving a known-good state before risky agent operations and rolling back on failure
• Per-agent VM isolation: Instead of shared runtimes, give each agent instance its own microVM to eliminate noisy-neighbor interference and security cross-contamination
• MCP-over-HTTP: Deploy Claude Code skills as stateful MCP servers on Fly.io for remote team access; use SSE transport for persistent connections
• Internal DNS for service discovery: Use .internal addresses to wire together agent components (coordinator, executor, storage) without exposing them publicly
• Per-second billing for burst workloads: Agent workloads are often bursty; Fly's billing model ensures idle agents cost nothing while allowing rapid scale-up

Integration Opportunities

• fly-mcp: Deploy the open-source fly-mcp Go server to allow Claude to manage Fly.io infrastructure via natural language (provision apps, check stats, scale services)
• Claude Code + Sprites REST API: Use @fly/sprites TypeScript SDK or api.sprites.dev REST API to programmatically provision sandboxes for each Claude Code task
• FLAME pattern on Fly.io: Fly.io's documentation references Elixir FLAME for spawning function-level VMs; the same pattern applies to spawning Claude sub-agents in isolated Machines
• Fly Postgres as agent memory: Use Fly Postgres with pgvector for long-term semantic memory stores accessible to agents via the private 6PN network
• GitHub Actions → Fly Deploy: CI/CD workflow where Claude Code generates code, tests pass, and flyctl deploys automatically to Fly.io

References

• Fly.io homepage (accessed 2026-02-23)
• Fly.io Architecture docs (accessed 2026-02-23)
• Fly Machines documentation (accessed 2026-02-23)
• Machines REST API (accessed 2026-02-23)
• Machines API OpenAPI spec (accessed 2026-02-23)
• Model Context Protocol on Fly.io (accessed 2026-02-23)
• Sprites — stateful agent sandboxes (accessed 2026-02-23)
• Fly.io Private Networking (6PN) (accessed 2026-02-23)
• Fly Postgres (Managed) (accessed 2026-02-23)
• flyctl GitHub repository (accessed 2026-02-23)
• fly-go SDK (accessed 2026-02-23)
• fly-mcp: MCP server for Fly.io infrastructure (accessed 2026-02-23)
• Fly.io introduces Sprites for agentic AI (devclass) (accessed 2026-02-23)
• Fly.io pricing (accessed 2026-02-23)
• WireGuard private network access (accessed 2026-02-23)

Freshness Tracking