# Fly

News, tips, and tricks from the team at Fly

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Petsem: Sometimes Dead Is Better

DevFeed: [Petsem: Sometimes Dead Is Better](<https://devfeed.tech/articles/petsem-sometimes-dead-is-better-146486.md>)

Original publisher: [Read original article](<https://fly.io/blog/petsem/>)

Author: Matt Braun

Published: 2026-11-20T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [HashiCorp Vault](<https://devfeed.tech/topics/hashicorp-vault.md>), [Credential theft](<https://devfeed.tech/topics/credential-theft.md>), [secret rotation](<https://devfeed.tech/topics/secret-rotation.md>), [Environment Variables](<https://devfeed.tech/topics/environment-variables.md>), [LLM security](<https://devfeed.tech/topics/llm-security.md>)

Tags: [ai-inference](<https://devfeed.tech/tags/ai-inference.md>), [api](<https://devfeed.tech/tags/api.md>), [api-key](<https://devfeed.tech/tags/api-key.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [consul](<https://devfeed.tech/tags/consul.md>), [delinea](<https://devfeed.tech/tags/delinea.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [environment-variables](<https://devfeed.tech/tags/environment-variables.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [hashicorp](<https://devfeed.tech/tags/hashicorp.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [infosec](<https://devfeed.tech/tags/infosec.md>), [llm](<https://devfeed.tech/tags/llm.md>), [log](<https://devfeed.tech/tags/log.md>), [machines](<https://devfeed.tech/tags/machines.md>), [networking](<https://devfeed.tech/tags/networking.md>), [nomad](<https://devfeed.tech/tags/nomad.md>), [orchestrator](<https://devfeed.tech/tags/orchestrator.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [service-discovery](<https://devfeed.tech/tags/service-discovery.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

Fly.io replaced Vault for customer secret reads with Petsem after Vault's single-region Raft setup made boot-time secret reads slow and dependent on IAD: p99 was 10 seconds. Petsem keeps a write master in IAD and uses read replicas across regions; allowing potentially stale reads reduced p99 to 300 ms. Macaroon discharge tokens let a worker read an app's secrets only when separately authorized for that app, with denied reads logged and alerted. This limits a compromised worker to secrets for apps placed there, but does not protect secrets in guest memory or prevent access to those apps' secrets. Fly.io began migration in March 2024, ran Petsem alongside Vault by May, and cut customer reads over in July 2025; Vault remains in use elsewhere. Fly KMS also provides encrypt, decrypt, sign, and verify operations without exposing the secret to the app.

### Source excerpt

It's a hard time to be in infosec. Not that it was ever easy, mind you, but nowadays it seems particularly bad, what with the speed at which LLM-powered attackers can explore, iterate, and exploit their victims. The balance of power has tipped in favor of attackers, and while as defenders we may be on the back foot, we can take some steps to try and mitigate risks. The risks, they are legion, but the first-and-foremost risk for any neocloud is an attacker hoovering up every cred and API key they can get their hands on. This isn't a new risk, though it does have an interesting modern-day twist: it used to be that attackers were looking for keys to, say, payment systems or other crown jewels. Now keys for AI inference providers are of particular interest. We offer these on Sprites via Connectors and for Machines via Tokenizer/SSOkenizer. So, protecting keys: the best case is to not have a key to protect in the first place (think: ambient identity or API gateways). But, if that's not an option, generally folks know not to hardcode keys in source or write them to config files (right?) and instead pull sensitive values from an external source and park them as environment variables. Of course, that shifts the responsibility elsewhere, but that's a fair tradeoff: one centralized authority that hosts can pull secrets from vs. having to manage pushing the secrets to N running hosts. And so we have API-driven secrets managers like CyberArk, Delinea (née Thycotic) Secret Server, and HashiCorp's Vault. Sure, attackers still can pull creds from a running or suspended system, that much is unchanged, but now operators can roll creds quickly, log access, and not have to deal with deployment headaches. Outgrowing Hashistack We wrote about replacing Consul in A Foolish Consistency and Corrosion, and about replacing Nomad with flyd in Carving The Scheduler Out Of Our Orchestrator. We like Hashistack. It's good, battle-hardened software. Fly.io was built on Consul for service discovery

## Well, That Wasn't Fun: October 16 '26

DevFeed: [Well, That Wasn't Fun: October 16 '26](<https://devfeed.tech/articles/well-that-wasn-t-fun-october-16-26-121085.md>)

Original publisher: [Read original article](<https://fly.io/blog/well-that-wasnt-fun/>)

Author: Daniel Botha

Published: 2026-11-06T00:00:00Z

Content type: news

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [fly.io](<https://devfeed.tech/topics/fly-io.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [virtualization](<https://devfeed.tech/topics/virtualization.md>), [TCP/IP](<https://devfeed.tech/topics/tcp-ip.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [payload](<https://devfeed.tech/topics/payload.md>), [network-intelligence](<https://devfeed.tech/topics/network-intelligence.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [about](<https://devfeed.tech/tags/about.md>), [based](<https://devfeed.tech/tags/based.md>), [bug](<https://devfeed.tech/tags/bug.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [card](<https://devfeed.tech/tags/card.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [chaos](<https://devfeed.tech/tags/chaos.md>), [checksums](<https://devfeed.tech/tags/checksums.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [code](<https://devfeed.tech/tags/code.md>), [corruption](<https://devfeed.tech/tags/corruption.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [customer](<https://devfeed.tech/tags/customer.md>), [cve](<https://devfeed.tech/tags/cve.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [example](<https://devfeed.tech/tags/example.md>), [exploit](<https://devfeed.tech/tags/exploit.md>), [field](<https://devfeed.tech/tags/field.md>), [fleet](<https://devfeed.tech/tags/fleet.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [fun](<https://devfeed.tech/tags/fun.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [networking](<https://devfeed.tech/tags/networking.md>), [october](<https://devfeed.tech/tags/october.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

Fly.io patched and rebooted its fleet after CVE-2026-99999 exposed a flaw in Linux IPv4 checksum-offload validation for virtual machine traffic. By redirecting checksum writes, an attacker could alter two trusted IPv4 header bytes after routing and firewall checks, enabling a firewall bypass or a 32-byte out-of-bounds read that might expose host or neighboring VM data. Fly.io says it has no evidence customer data was exposed, but advises customers who ran there October 15-17 to rotate credentials sent over unencrypted protocols, including plaintext traffic over 6PN. The 10-hour rollout required staggered host reboots to limit disruption to Managed Postgres clusters; some machines remained down after hardware and reinstall problems, with no machines or customer data lost. Fly.io also revised incident communications so executives own the communication plan. Its practical security guidance includes encrypting internal traffic, using scoped and expiring agent credentials, limiting shared exposure across trust boundaries, treating agent inputs as hostile, and rehearsing credential rotation.

### Source excerpt

October 16, 2026 began like any other day at Fly.io (meaning, we were anticipating only a medium amount of chaos). By that evening, we had patched and rebooted our entire fleet in response to a Linux kernel bug. The full rollout took 10 hours, but the emotional damage persists. CVE-2026-99999 The rest of this won't make much sense without a clear read on the bug itself, so: the Linux kernel CVE team and pwn.ai announced CVE-2026-99999 on the morning of the 15th. We heard about it that night, and started working on mitigations. IP sleight of hand Protocols like TCP and UDP include checksums to detect corruption on the way across the internet. Calculating one means reading the whole message, which adds up at high speeds. Linux avoids that with checksum offload: instead of calculating the checksum immediately, the kernel stores metadata saying where the checksum should read from and write to. If the checksum turns out not to be needed, the kernel never spends the CPU on it. Not needed, for example, when sending to localhost, or when the network card can add its own checksums. Checksum offload works the same way for virtual machines. The virtual network card accepts checksum metadata and passes it to the host. On the host side, the packet is treated like any other offloaded packet, using the metadata the guest provided. The offload code has checks meant to reject bad metadata. For IPv4, they were wrong. To exploit that, an attacker needs to do three things: point the checksum at a different header field, pick a message that produces the checksum they want, and force the host to calculate the checksum in software. The pwn.ai post goes into detail on pulling that off. The end result: the host receives the packet, parses it, decides where to send it, then applies the checksum, in the wrong place. The attacker now controls two bytes of an IPv4 header the host has already trusted. Based on network activity during the rollout, we believe it's unlikely that any of our customer

## Feng Shui for Robots: The Fly MCP Server

DevFeed: [Feng Shui for Robots: The Fly MCP Server](<https://devfeed.tech/articles/feng-shui-for-robots-the-fly-mcp-server-97514.md>)

Original publisher: [Read original article](<https://fly.io/blog/feng-shui-for-robots/>)

Author: Daniel Botha

Published: 2026-10-23T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>), [cloud-migration](<https://devfeed.tech/topics/cloud-migration.md>)

Tags: [2023](<https://devfeed.tech/tags/2023.md>), [2025](<https://devfeed.tech/tags/2025.md>), [2026](<https://devfeed.tech/tags/2026.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [apps](<https://devfeed.tech/tags/apps.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [code](<https://devfeed.tech/tags/code.md>), [computers](<https://devfeed.tech/tags/computers.md>), [databases](<https://devfeed.tech/tags/databases.md>), [databricks](<https://devfeed.tech/tags/databricks.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [environment](<https://devfeed.tech/tags/environment.md>), [files](<https://devfeed.tech/tags/files.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [server](<https://devfeed.tech/tags/server.md>), [servers](<https://devfeed.tech/tags/servers.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

Fly.io's `mcp.fly.io` connects agents to Sprites for development and Fly.io apps for production. Sprites provide Linux environments where agents can install packages, persist files across restarts, run services, expose HTTPS endpoints and checkpoint or roll back the filesystem. When an app needs to stay available, the agent can use the same MCP server to create a Fly Machine, volume and secrets, moving a Linux service between Linux machines. Setup uses browser authorization to select organizations, apps and Sprite permissions; access is limited to approved apps, and IP addresses and certificates are readable but not writable. Scheduled Sprite jobs are described as forthcoming, and adding MPG skills for managed Postgres is under investigation. This overview reflects the supplied excerpt.

### Source excerpt

In Databricks' State of AI Agents 2026 report, there's a chart from Neon's telemetry that's somehow both mind-blowing and unsurprising. In October 2023, AI agents created 0.1% of the databases on Neon. By October 2025 they created 80% of them. We're seeing this play out all across the infra landscape, including here at Fly.io, where agents have overtaken humans as our most common customer species. Thing is, we think it's important to remember that there's a human with aspirations behind those agents. Often one trying to build something that actually makes it to prod. If we want to make that easy, "computers for agents" can't just be a sandbox where an agent can vibe. Agents need a whole cloud now. Somewhere safe to try dumb stuff, sure, but also a dead simple migration path to, and all the requisite parts of, a scalable production environment. This is kinda our whole thing right now. So we built mcp.fly.io: one MCP server that connects your agent to Sprites and to your Fly.io apps. Start with a Sprite Building something real with an agent should start in a sandbox. The speed and scale at which you can test different approaches and solutions is easily one of the most significant benefits of building with agents. So you want them to be able to kick all the tires to find out which of them explode. This is why the sandbox you choose in this step is so important. There are plenty of places to safely execute agent code. But what you want is to actually install packages, write files, start a server on a port, hit the server, and see what restarting the server does in real life. This is how you get from vibes to a robust product. It's why you should tell your agent to build in a Sprite. Just Linux, all the way down When your agent builds something on a Sprite, it builds it the way it would on any Linux box. Packages go where packages go. Files sit on a disk that survives sleeps and restarts. The server runs as a service, a long-running process that survives the Sprite reboo

## SBD: We Have a Filesystem at Home

DevFeed: [SBD: We Have a Filesystem at Home](<https://devfeed.tech/articles/sbd-we-have-a-filesystem-at-home-95252.md>)

Original publisher: [Read original article](<https://fly.io/blog/sprites-block-device/>)

Author: Daniel Botha

Published: 2026-10-22T00:00:00Z

Content type: release

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [Ext4](<https://devfeed.tech/topics/ext4.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>), [Disk image](<https://devfeed.tech/topics/disk-image.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [mount](<https://devfeed.tech/topics/mount.md>), [NVMe](<https://devfeed.tech/topics/nvme.md>)

Tags: [block](<https://devfeed.tech/tags/block.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [database](<https://devfeed.tech/tags/database.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [device](<https://devfeed.tech/tags/device.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [ext4](<https://devfeed.tech/tags/ext4.md>), [filesystem](<https://devfeed.tech/tags/filesystem.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [linux](<https://devfeed.tech/tags/linux.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [networking](<https://devfeed.tech/tags/networking.md>), [object](<https://devfeed.tech/tags/object.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [servers](<https://devfeed.tech/tags/servers.md>), [storage](<https://devfeed.tech/tags/storage.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

Sprites replaces its heavily modified JuiceFS setup with the Sprites Block Device (SBD): a daemon presents bucket-backed storage to Linux as an NBD block device, which Sprite formats as ext4. The prior design stored a 100 GB disk image and relied on separate JuiceFS metadata and checkpoint databases; writeback could leave metadata pointing to an object that was never uploaded, and cloned checkpoints could share that missing chunk. SBD keeps volume metadata with the blocks in the bucket, caches locally, uploads dirty blocks in the background, and flushes when durability must be guaranteed. Checkpoints record block snapshots and volume versions in SBD's catalog; restore rewinds the volume in place. SBD verifies blocks read from storage and restarts the Sprite if its daemon dies, favoring a clean restart over continued use of an untrusted disk. The post reports that stress testing and design partner feedback found SBD orders of magnitude more reliable, and says it will replace the old filesystem.

### Source excerpt

I have unkind things to say about people who make their own pasta. Here, I'll only use them as an example of how not to think when you're building infrastructure. It's unfairly easy to believe that the harder you work on something, the better it gets. But infra is about making the $1 bag of spaghetti: a simple thing that works well (and doesn't require you to spend a week scraping flour out of the corners of your kitchen). When work on Sprites started, it was a new kind of infra for a new kind of product. So when we couldn't find the right filesystem in the pasta section, we made our own. It was clever, and that's exactly why we didn't like it. This post introduces its replacement, the Sprites Block Device (SBD). It's the bag of spaghetti you grab off the shelf, and the only difference you'll notice is better reliability. It was always object storage Our stance on one core aspect of Sprites' storage hasn't changed from v1: the root of a Sprite's disk is object storage, not the NVMe in whatever server the Sprite happens to be running on. That's what lets a Sprite sleep, wake on a different server, and still find its files where it left them. The durable state of a Sprite is, more or less, a location in a bucket. We wrote about why, at length, with feeling. The thing about object stores is they can't change part of an object. To change one byte, you have to replace the whole thing. That's a bad cultural fit for Linux programs which rewrite a few bytes in the middle of a file all the time. Something has to handle that translation. At launch, that something was a heavily modded version of JuiceFS. In stock form, JuiceFS splits storage into the data (as chunks in the bucket) and the metadata (a map of which chunks make up which files) in a database. That's not how we used it, though. Our hot rodded version ran a rewritten SQLite metadata backend, kept durable with Litestream. It stored exactly one file: a 100 GB disk image, mounted on a loop device with ext4 inside. Linu

## Your Agent Speaks MCP. Give It a Computer.

DevFeed: [Your Agent Speaks MCP. Give It a Computer.](<https://devfeed.tech/articles/your-agent-speaks-mcp-give-it-a-computer-1717.md>)

Original publisher: [Read original article](<https://fly.io/blog/sprites-mcp/>)

Published: 2026-09-03T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [MSP MCP](<https://devfeed.tech/topics/msp-mcp.md>), [AI Bots](<https://devfeed.tech/topics/ai-bots.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [api](<https://devfeed.tech/tags/api.md>), [auth](<https://devfeed.tech/tags/auth.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [cli](<https://devfeed.tech/tags/cli.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [codex](<https://devfeed.tech/tags/codex.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [filesystems](<https://devfeed.tech/tags/filesystems.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [skills](<https://devfeed.tech/tags/skills.md>)

### AI overview

The article presents Sprites as disposable cloud computers for coding agents and explains using their API through MCP. It argues that MCP transport and progressive capability disclosure can work together, including through plugins and skills.

### Source excerpt

Sprites are disposable cloud computers. They appear instantly, always include durable filesystems, and cost practically nothing when idle. They're the best and safest place on the Internet to run agents and we want you to create dozens of them. Sprites are a place to run agents; the first thing you should think to do with a new Sprite is to type claude (or gemini or codex). We've put a lot of effort into making sure coding agents feel safe and happy when they're on Sprites, because, to (probably) quote John von Neumann, "happy agents are productive agents." What's less obvious about Sprites is that they're great tools for agents. Want three different versions of a new feature? A test environment? An ensemble of cooperating services? It's super handy to be able to start your prompts, "On a new Sprite, do...". The Sprites API is simple, discoverable, and designed for this use case. The only real question is how your agent reaches it. For most of you the answer is MCP, and the setup is already written. You Don't Have To Pick There's an argument going around that MCP is the wrong way to extend an agent, and that command line tools and discoverable APIs are the Right Way. Half of that argument is correct, and it's the important half, so let's take it seriously. Dumping thirty tool descriptions into a context window is a bad way to teach anything. Not every Sprite command matters in every session, and cramming them all in signals to the model that they all matter to you. If you're not using network policies, gemini shouldn't burn a single token learning to configure them. Capabilities should reveal themselves progressively, the way they do when an agent works out a CLI one subcommand at a time. The wrong half is treating that as a case against MCP. Progressive disclosure is a question of what you say to the model. MCP is a question of how the bytes get there: transport, auth, structured results, a tool the model can call instead of a command whose flags it has to guess. Tho

## Turn And Face The Strange

DevFeed: [Turn And Face The Strange](<https://devfeed.tech/articles/turn-and-face-the-strange-1702.md>)

Original publisher: [Read original article](<https://fly.io/blog/kurt-scott-money-sprites/>)

Published: 2026-07-24T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-infrastructure](<https://devfeed.tech/tags/cloud-infrastructure.md>), [coding](<https://devfeed.tech/tags/coding.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

Fly.io says it is raising more money, launching a new iteration of Sprites--computers for agents--and refocusing the company around that product as AI reshapes software development.

### Source excerpt

We're Fly.io, a public cloud platform that is both our favorite way to put an app on the Internet and our favorite way to safely let a frontier agent coding harness cook. This is a post about our company, the future, and Sprites, which are computers for agents that you can check out right now. This is a complicated post. So I need you to promise me something: if you read past this introduction, you'll read the whole rest of the way through. It's an honor thing. A couple months back, Theo Browne ran a video rating the "best place to host a new application in 2026". Theo tends to say nice things about us. He did this time too. But then he concluded by saying that of all the providers he pays attention to, we were the one he was least confident would be around by the end of the year. Well, fuck. Theo startled us, because we're in the middle of a run of strong quarters that have included the best financial months in the company's history. But that take has been rattling around in my brain. It whacked me right on a raw nerve, about what we're doing and where we're going as a company. Honestly, I should've seen this coming. Fly.io has been motoring along this year, but I've coasted a bit, letting the company smolder in an unresolved identity crisis. I'm going to overshare some more in a second, but I won't leave you hanging. So: we've raised a bunch more money. We're launching a new iteration of Sprites, and focusing the company on them and the problem they solve. And I'm tagging in Scott Johnston as CEO. Product-Market Fit I started Fly.io with two clear principles that probably don't matter anymore. The first is that Internet applications work best when they're fast, and that happens when they're deployed close to users. I learned this over many years of working at Ars Technica, and started Fly.io in part to scratch an itch. It was our mantra over the first several years of the company. The second is that cloud infrastructure is too complicated. Developers need platform

## Building Agents that Don't Break Themselves

DevFeed: [Building Agents that Don't Break Themselves](<https://devfeed.tech/articles/building-agents-that-don-t-break-themselves-1690.md>)

Original publisher: [Read original article](<https://fly.io/blog/building-agents-that-dont-break-themselves/>)

Published: 2026-06-08T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [AI Bots](<https://devfeed.tech/topics/ai-bots.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [bash](<https://devfeed.tech/tags/bash.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [networking](<https://devfeed.tech/tags/networking.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [sandbox](<https://devfeed.tech/tags/sandbox.md>), [sandboxes](<https://devfeed.tech/tags/sandboxes.md>), [servers](<https://devfeed.tech/tags/servers.md>)

### AI overview

A tutorial on keeping long-lived AI agents safe by separating the agent process from risky shell execution. It recommends running each potentially destructive task in an isolated, disposable Sprite rather than letting the agent execute commands in its own environment.

### Source excerpt

Building agents is fun. Rebuilding agents that break themselves... less so. A lot of Fly people are building agents with less of a penchant for self-destruction by teaching their agents to do anything risky in a Sprite. You get an agent that stays alive long enough to actually use its snazzy self-improvement features, and you can allow your agent to try things that would otherwise be battleship-scale footguns. Here's how to do it. Brains vs Hands Your agent would be pretty useless without a shell, because this is where it does agent things. Run the test suite, apply the migration, install the dependency, delete the temp files. Unfortunately, your agent's shell access is also what tends to ruin your afternoon, simply because "delete the temp files" and "delete the wrong files" are one fat-fingered glob apart, and as we're frequently warned, AI can make mistakes. This is why we have sandboxes. But a lot of people default to putting an agent that's going to do potentially scary work in a sandbox. This comes with a long list of tradeoffs that you really don't have to make, because where your agent lives and where it runs code are two entirely separate considerations. PPE for agent workers. The agent process is a loop. It calls a model, reads the response, picks a tool, rinse and repeat. It's a long-lived process that only becomes more competent and less stupid if memory, skills and history persist. So a Fly Machine that sleeps when idle and wakes on a message, a small VPS. Your laptop while you iterate. These are all fine homes for a loop calling an API, which doesn't need a blast shield. It's when you want your agent to execute that things get hairy. bash -c + whatever string the model just produced needs to be run in a padded room. Somewhere where the agent's code can't break itself or anything connected to it. And if your agent is doing more work than you are, you're going to want a whole facility of padded rooms that can be thrown away and rebuilt on a whim. One Sprit

## Run Paperclip AI on a Sprite

DevFeed: [Run Paperclip AI on a Sprite](<https://devfeed.tech/articles/run-paperclip-ai-on-a-sprite-122061.md>)

Original publisher: [Read original article](<https://fly.io/blog/paperclip-on-a-sprite/>)

Author: Daniel Botha

Published: 2026-04-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [self-service](<https://devfeed.tech/topics/self-service.md>), [free software](<https://devfeed.tech/topics/free-software.md>), [Claude](<https://devfeed.tech/topics/claude.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [computer](<https://devfeed.tech/tags/computer.md>), [config](<https://devfeed.tech/tags/config.md>), [database](<https://devfeed.tech/tags/database.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [execution](<https://devfeed.tech/tags/execution.md>), [file-storage](<https://devfeed.tech/tags/file-storage.md>), [node](<https://devfeed.tech/tags/node.md>), [npx](<https://devfeed.tech/tags/npx.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [paperclip](<https://devfeed.tech/tags/paperclip.md>), [paperclip-ai](<https://devfeed.tech/tags/paperclip-ai.md>), [paperclipai](<https://devfeed.tech/tags/paperclipai.md>), [port](<https://devfeed.tech/tags/port.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [resume](<https://devfeed.tech/tags/resume.md>), [robots](<https://devfeed.tech/tags/robots.md>), [self-host-paperclip](<https://devfeed.tech/tags/self-host-paperclip.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

The excerpt shows how to run Paperclip, an open-source platform for organizing AI agents, on a Sprite. Create a Sprite, install Paperclip with `npx paperclipai onboard -y` (which uses embedded PostgreSQL, local file storage, and port 3100 by default), then configure authenticated access, bind the server to `0.0.0.0`, allow the Sprite hostname, and register the app as a service. The article also describes checking the health endpoint, retrieving the dashboard URL, and creating an admin account. Sprites provide hardware isolation, checkpoints that can restore the environment and agent state, and automatic pause/resume to reduce idle costs. Their network policy can restrict which domains agents reach. The excerpt notes that making the Sprite URL public removes Fly.io authentication while Paperclip's own login remains in place.

### Source excerpt

Paperclip is extremely hot right now. I'm not going to explain what it is in any detail here because you have YouTube. But in short: it's an open-source orchestration platform that lets you set up teams of AI agents that operate like a company. Org charts, goals, budgets, autonomous execution. It's perfect for people who want a team of robots to do all the work that they issue from a dimly lit room in which they stroke a cat and sip from a crystal glass. It is genuinely cool and appears to have real utility. So it's a safe bet that Mac Minis are sold out in every store in your city again. Fortunately, Sprites people have already forgotten what it feels like to have something as trivial as hardware scarcity get in the way of building cool things. Let's get a Sprite to run our Paperclip on: Wrap text Copy to clipboard sprite create paperclip Now we have a hardware-isolated Linux computer with 100GB of storage, its own URL with TLS, and a pause/resume lifecycle that means you only pay for it when it's actually doing something. Setup Node 22 is already in your Sprite. So this is the whole install: Wrap text Copy to clipboard npx paperclipai onboard -y The -y flag accepts all defaults: embedded PostgreSQL, local file storage, port 3100. It creates your config, sets up the database, generates secrets. Done. Make It Reachable and Register the Service Paperclip's default config binds to 127.0.0.1 in local_trusted mode. You're not sitting at this machine, so it needs to bind to 0.0.0.0 in authenticated mode, get told about your Sprite's hostname, and be registered as a Sprite service. Tell Claude: In ~/.paperclip/instances/default/config.json, change server.deploymentMode to "authenticated" and server.host to "0.0.0.0". Then run npx paperclipai allowed-hostname with this Sprite's hostname (get it from sprite-env info). Then register Paperclip as a Sprite service called "paperclip" using sprite-env services create with the command npx (use which npx to get the full path), arg

## Run a Local LLM on a CPU With BitNet and a Sprite

DevFeed: [Run a Local LLM on a CPU With BitNet and a Sprite](<https://devfeed.tech/articles/run-a-local-llm-on-a-cpu-with-bitnet-and-a-sprite-122058.md>)

Original publisher: [Read original article](<https://fly.io/blog/local-llm-on-a-sprite/>)

Author: Daniel Botha

Published: 2026-03-16T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [Local AI](<https://devfeed.tech/topics/local-ai.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [hosting](<https://devfeed.tech/topics/hosting.md>), [llama.cpp](<https://devfeed.tech/topics/llama-cpp.md>), [Open Source Models & Datasets](<https://devfeed.tech/topics/open-source-models-datasets.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-swarm](<https://devfeed.tech/tags/agent-swarm.md>), [bitnet](<https://devfeed.tech/tags/bitnet.md>), [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [classification](<https://devfeed.tech/tags/classification.md>), [claude](<https://devfeed.tech/tags/claude.md>), [cli](<https://devfeed.tech/tags/cli.md>), [code](<https://devfeed.tech/tags/code.md>), [compute](<https://devfeed.tech/tags/compute.md>), [computer](<https://devfeed.tech/tags/computer.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpu-inference](<https://devfeed.tech/tags/cpu-inference.md>), [cpus](<https://devfeed.tech/tags/cpus.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [engines](<https://devfeed.tech/tags/engines.md>), [environment](<https://devfeed.tech/tags/environment.md>), [falcon](<https://devfeed.tech/tags/falcon.md>), [files](<https://devfeed.tech/tags/files.md>), [llm](<https://devfeed.tech/tags/llm.md>), [local](<https://devfeed.tech/tags/local.md>), [local-llm](<https://devfeed.tech/tags/local-llm.md>), [run-llm-locally](<https://devfeed.tech/tags/run-llm-locally.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

The article describes running Microsoft's BitNet-b1.58-2B-4T locally on a CPU-equipped Sprite and exposing it as a shared inference service. It reports a 1.1 GB model, about 1.3 GB total RAM use, roughly 50 tokens per second, and about 1.4 seconds end-to-end latency. A small Python server wraps llama-cli with an OpenAI-compatible chat endpoint, status page, browser chat UI, and a self-hosted stdlib client offering ask() and classify(). Sprites sleep between requests, then wake, load the model in about 1.2 seconds, respond, and sleep again, which the author presents as useful for bursty tasks without idle compute. Checkpoints capture the environment, weights, binaries, and server together, enabling experiments with models, kernels, and prompt formats and rollback if changes break service. The text also gives build guidance and frames the model as suitable for classification, extraction, triage, or routing, while acknowledging its limited intelligence and suggesting frontier-model fallback for harder reasoning.

### Source excerpt

There's a wave of absurdly efficient local inference engines showing up. Models quantized so aggressively that they run on CPUs, no GPU required, at speeds that are actually usable. Microsoft's BitNet is one of them: 1.58-bit quantization, ternary weights, optimized SIMD kernels. A 2.4 billion parameter model that fits in 1.1GB of RAM. So naturally, I needed to see if one of these little guys could achieve something approaching acceptable performance, running on a Sprite. And if it could, how much time could I waste wondering what I could do with a tiny LLM running on a hardware-isolated computer? Why though? Sprites spin up with access to frontier models literally one CLI command away. Claude is right there. So why would I want to get a puny little 2B model running locally on a Sprite? Because a tiny local model on a Sprite is not the same as a tiny local model on your laptop. Every Sprite already has a URL with TLS. Stand up an HTTP server, register it as a service, and now any other Sprite on your account can call it. Your agent swarm just gained a shared inference endpoint by adding one more Sprite to the fleet. No infrastructure changes, no new dependencies, just another URL. The Sprite sleeps when nobody's calling it. A request arrives, the Sprite wakes, the model loads (~1.2 seconds), inference runs, response goes back, Sprite goes back to sleep. That lifecycle doesn't exist on a VPS. You're not paying for idle compute between bursts of classification requests at 3am. Checkpoints are amazing for working with local models With a local model, the environment is the product. The compiled kernels, the model weights, the server code, the Python deps, it's all files on disk. A checkpoint captures the entire thing atomically. I can hear you asking who gives a shit, but think about that for a minute. You have BitNet-2B running and serving requests. You want to try the 3B model. Or a Falcon variant. Or you want to retune the kernel parameters for better throughput. On

## Context Engineering Is Just Writing Things Down

DevFeed: [Context Engineering Is Just Writing Things Down](<https://devfeed.tech/articles/context-engineering-is-just-writing-things-down-122055.md>)

Original publisher: [Read original article](<https://fly.io/blog/context-engineering-is-just-writing-things-down/>)

Author: Daniel Botha

Published: 2026-02-23T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [hybrid-search](<https://devfeed.tech/topics/hybrid-search.md>), [Prompt Engineering](<https://devfeed.tech/topics/prompt-engineering.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [OpenClaw](<https://devfeed.tech/topics/openclaw.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-context](<https://devfeed.tech/tags/agent-context.md>), [bm25](<https://devfeed.tech/tags/bm25.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [claude-md](<https://devfeed.tech/tags/claude-md.md>), [commands](<https://devfeed.tech/tags/commands.md>), [context](<https://devfeed.tech/tags/context.md>), [context-engineering](<https://devfeed.tech/tags/context-engineering.md>), [daily](<https://devfeed.tech/tags/daily.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [environment](<https://devfeed.tech/tags/environment.md>), [hooks](<https://devfeed.tech/tags/hooks.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [local](<https://devfeed.tech/tags/local.md>), [memory](<https://devfeed.tech/tags/memory.md>), [model](<https://devfeed.tech/tags/model.md>), [openclaw](<https://devfeed.tech/tags/openclaw.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [project](<https://devfeed.tech/tags/project.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [relevance](<https://devfeed.tech/tags/relevance.md>), [search](<https://devfeed.tech/tags/search.md>), [skills](<https://devfeed.tech/tags/skills.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

The excerpt argues that agent performance depends heavily on project and environment context, and shows how files and persistent Sprite state can supply it. OpenClaw's daily logs are append-only and lose relevance over time, while MEMORY.md changes only when information is deliberately promoted. Recall combines BM25 keyword search and vector search at a 70/30 weighting, then reranks for diversity, using local SQLite. For a project, the author recommends CLAUDE.md for conventions and commands, Skills for repeated workflows, Hooks for live environment and git state, and Checkpoints to preserve the setup. In the Alibi example, a preflight skill runs tests, type checks, lint, and TODO checks in order, stopping at the first failure; hooks surface service and repository state. The excerpt's bug-fix scenario illustrates how that context can guide a fix and regression test. It presents these as practical techniques, not revolutionary features.

### Source excerpt

"Context engineering" is the internet's new shibboleth. Fine. We've had worse. So here's an argument starter: The only interesting thing about OpenClaw is its context engineering. The way it manages and inserts memory into agent context. Yes, this is because I live in a world where everything you need from a computer is just a few prompts away. So no, I don't think a Slack connector or a WhatsApp bridge is interesting. The memory system is cool though. People are having fun with SOUL.md because it lets you set a persistent personality and some behavioral traits. MEMORY.md is ... memories, and daily logs capture ongoing session context, but these are standard agent equipment. What's worth a look is how each of these are managed. Daily logs are append-only and decay in relevance over time. They're noise with signal in it. MEMORY.md doesn't decay, it only changes when the agent or the user deliberately promotes something into it. One is a stream, the other is curated. Then there's memory recall. A hybrid of keyword search (BM25) and vector search, weighted 70/30, with diversity re-ranking so you don't get five variations of the same result. It finds both exact matches like error codes and conceptual matches like "that thing we discussed about auth." All backed by local SQLite. Of course these aren't revolutionary features, but they serve to make my point. The quality of an agent's work is far more dependent on how much it knows about your project and its environment than it is about model capability. This is why we're working our collective ass off to help Sprites understand how to operate themselves and other Sprites with built-in documentation. Just Tell Claude To Do It covered what comes in the box. But when it comes to your specific Sprite project, these should be considered a starting point. There are four different ways to make your Sprite better at working on your project: CLAUDE.md -- project conventions, commands, patterns. Claude reads this on every session. Ski

## Agent Swarms on Sprites

DevFeed: [Agent Swarms on Sprites](<https://devfeed.tech/articles/agent-swarms-on-sprites-122053.md>)

Original publisher: [Read original article](<https://fly.io/blog/agent-swarms-on-sprites/>)

Author: Daniel Botha

Published: 2026-02-09T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [supervisor agent pattern](<https://devfeed.tech/topics/supervisor-agent-pattern.md>), [hierarchical agent systems](<https://devfeed.tech/topics/hierarchical-agent-systems.md>), [agent to agent communication](<https://devfeed.tech/topics/agent-to-agent-communication.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-swarm](<https://devfeed.tech/tags/agent-swarm.md>), [agent-teams](<https://devfeed.tech/tags/agent-teams.md>), [agents](<https://devfeed.tech/tags/agents.md>), [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [blast-radius](<https://devfeed.tech/tags/blast-radius.md>), [built-in](<https://devfeed.tech/tags/built-in.md>), [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code-agent](<https://devfeed.tech/tags/code-agent.md>), [computer](<https://devfeed.tech/tags/computer.md>), [console](<https://devfeed.tech/tags/console.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [laptop](<https://devfeed.tech/tags/laptop.md>), [machine](<https://devfeed.tech/tags/machine.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [multiple-agents](<https://devfeed.tech/tags/multiple-agents.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

The excerpt presents Sprites as isolated, persistent machines for agent swarms: each worker gets its own environment, independently restorable checkpoints, and a network policy, avoiding shared filesystem and dependency conflicts. An orchestrator using a Sprites API token and Claude Code can create workers, assign tasks, then collect results through Sprite HTTP endpoints, a shared Postgres Sprite, or by reading worker files. Workers can checkpoint before risky changes and try separate approaches; the orchestrator can restore or discard them. Sprites pause when idle and wake on demand, preserving workers and checkpoints across laptop shutdowns. The excerpt gives no comparative measurements or setup details beyond a sample worker prompt.

### Source excerpt

There's a lot of noise right now about agent teams and swarms. The idea is simple: instead of one code agent grinding through a task list, set up a group of agents that can split work, delegate, and check each other's output. It works. Multiple agents in parallel genuinely get more done. The part that nobody has a great answer for is the environment. Where do these agents actually run? Most setups put them all on the same machine; same filesystem, same network, same blast radius. Agent A installs Node 23, Agent B needs Node 20. Two agents write to the same file. One runs pip install sketchy-package and now everyone's environment is different. An agent swarm on Sprites comes with some handy capabilities. Full machine isolation per agent, checkpoints that let you roll back any agent independently, per-agent network policies, and persistence that survives you closing your laptop. One Agent, One Sprite When each agent lives in its own computer, agent teams work more like human teams. Everyone has their own desk. They can install whatever they need, make a mess, try things -- without touching anyone else's work. The orchestrator hands out assignments and collects results. No shared state to babysit. All you need is a Sprites API token (create one at sprites.dev/account/{your-org}/tokens) and Claude Code on the orchestrator. Prompt: Create a new Sprite called "researcher". When it's ready, open a console and tell Claude to read the codebase at /home/sprite/myproject and write a summary of the architecture to /home/sprite/output/architecture.md. Use --dangerously-skip-permissions so it can work autonomously. The orchestrator Sprite creates the worker, gives it a task, and moves on. The worker does its thing independently. The orchestrator can check in later, read the output, or wait for the worker to finish. Checkpoints Are Your Undo Button Every Sprite has checkpointing built in. Claude inside a worker Sprite can checkpoint its own environment before doing anything risky --

## Closing the Loop: The Missing Ingredient in Agentic Development

DevFeed: [Closing the Loop: The Missing Ingredient in Agentic Development](<https://devfeed.tech/articles/closing-the-loop-the-missing-ingredient-in-agentic-development-122054.md>)

Original publisher: [Read original article](<https://fly.io/blog/closing-the-loop/>)

Author: Daniel Botha

Published: 2026-02-05T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [observability](<https://devfeed.tech/topics/observability.md>), [AI in frontend development](<https://devfeed.tech/topics/ai-in-frontend-development.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [ai](<https://devfeed.tech/tags/ai.md>), [browsers](<https://devfeed.tech/tags/browsers.md>), [build](<https://devfeed.tech/tags/build.md>), [chat](<https://devfeed.tech/tags/chat.md>), [checkpoint](<https://devfeed.tech/tags/checkpoint.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [code-agent](<https://devfeed.tech/tags/code-agent.md>), [coding](<https://devfeed.tech/tags/coding.md>), [complex](<https://devfeed.tech/tags/complex.md>), [computer](<https://devfeed.tech/tags/computer.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [development](<https://devfeed.tech/tags/development.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [guardrails](<https://devfeed.tech/tags/guardrails.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [http](<https://devfeed.tech/tags/http.md>), [playwright](<https://devfeed.tech/tags/playwright.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

The excerpt argues that code agents can iterate with less human intervention when they can run and inspect their work inside a Sprite, described as a hardware-isolated computer. Sprites provide service logs at known paths, live HTTP URLs when servers start, and checkpoint rollback for risky changes. Included tools support API checks (curl, jq, httpx), SQLite inspection, language test runners, log review, and network debugging. Playwright is not preinstalled; the excerpt says to install it with `npm install playwright` and `npx playwright install chromium` for browser tests, screenshots, and rendering checks. It presents these tools as enabling an agent to build, test, diagnose, and retry without repeated permission prompts, while contrasting that workflow with granting broad autonomy on a laptop.

### Source excerpt

Remember when coding with AI meant copying code from a chat window, pasting it into your editor, running it, copying the error, pasting it back into the chat, etc. Yeah that sucked. We were middleware. Now we have agents that can read and write inside our code bases, which makes them feel a lot more like legit tools. But answering Claude's permission checks 150 times a session is the new copy/pasting from chat. It's annoying. Working with a code agent in a Sprite feels like the next step. In a Sprite, the answer to "can I try this" is always yes. Install dependencies, start servers, hit endpoints, run browsers, just do it and let me know when it's working. Thing is, if you want the joy of watching a code agent nail even complex builds regularly, it needs to be able to "see" what it has built, test its work and troubleshoot issues without needing your feedback. This is exactly why Sprites come with test and observability tooling preinstalled. Closing the Loop Code agents have gotten pretty good at testing their own output, trying different approaches and iterating. And with access to the right tools, a completely agent-driven build>test>ship pipeline is entirely possible. But it would be insane to prompt your agent, give it the "yes to all" freedom it needs and go to bed. If its running on your laptop that is. In a Sprite, the agent is working inside a fully hardware-isolated computer. It doesn't need guardrails or baby proofing of any kind. But it also gains powers it could never have on your laptop. Service logs at known paths. Checkpoint-based rollback that the agent knows how to use. An HTTP URL that's live the moment a server starts. The result is a tight loop: the agent writes code, starts a service, hits the endpoint, sees what's wrong, fixes it, and tries again. No permission prompts, no asking you to check something, no guessing. The Tools Are Already in Your Sprite Most of what your agent needs to operate like this is already installed in your Sprite. It al

## I Build Everything In Sprites Now

DevFeed: [I Build Everything In Sprites Now](<https://devfeed.tech/articles/i-build-everything-in-sprites-now-122057.md>)

Original publisher: [Read original article](<https://fly.io/blog/i-build-everything-in-sprites-now/>)

Author: Daniel Botha

Published: 2026-02-03T00:00:00Z

Content type: opinion

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [fly.io](<https://devfeed.tech/topics/fly-io.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [versioning](<https://devfeed.tech/topics/versioning.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [cloud-development-environment](<https://devfeed.tech/tags/cloud-development-environment.md>), [costs](<https://devfeed.tech/tags/costs.md>), [dashboard](<https://devfeed.tech/tags/dashboard.md>), [database](<https://devfeed.tech/tags/database.md>), [development](<https://devfeed.tech/tags/development.md>), [environment-variables](<https://devfeed.tech/tags/environment-variables.md>), [fly-io-sprites](<https://devfeed.tech/tags/fly-io-sprites.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [projects](<https://devfeed.tech/tags/projects.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

The author uses a separate persistent Sprite for each project to avoid conflicts between local runtimes, databases, environment variables, and services. Sprites are described as hardware-isolated Linux computers with 100 GB storage that incur costs only while active; they pause when idle and wake within seconds with services and state restored. Each Sprite provides its own ports and an HTTPS URL, which the author says supports OAuth callbacks, webhooks, and sharing a live project view without tunneling. Checkpoints snapshot the whole environment, including dependencies, database state, services, and environment variables, for restoring experiments. The author also favors a project-specific Claude and context per Sprite, with skills propagated to other Sprites through the API. These are the author's reported workflows and product claims in the supplied text.

### Source excerpt

I just realised I build everything in Sprites now. It feels weird to say because Sprites are still really new (even for people who work at Fly.io). They're obviously super exciting for people building agents, but when I finally "got" Sprites, it pretty much instantly felt weird to build anything anywhere else. If, like me, you have to flit between many projects every day - because breaking only one thing a day is lazy - you'll know that local development is a joke. Let me pause what I'm working on to fix this tiny bug over on this other project! Wrong Node version. asdf local nodejs 18.17.0. Oh wait, this project uses nvm. Fine. nvm use. No .nvmrc file. Check the README. Last updated in 1996. Check package.json engines field. Install that version. Now the wrong packages are installed. Ah, productivity. Oh of course, the wrong database is running. Start Postgres. Wait, this project uses MySQL. Stop Postgres, start MySQL. Except the other project's MySQL data is still there. Where's the docker-compose for this one? Ah I have screwy environment variables, let me just update the ... wait is it .env, .env.local, .env.development, .env.example, env.thisone? This project needs API_KEY set but that collides with the other project's API_KEY which points somewhere else. Swear I have a .env.projectname file somewhere. Maybe. Which shell session has the right exports? Yes! It's running! Wait what was I doing again? No. Just No. Now every project I'm working on is in its own Sprite. It feels like having a different computer for every project because that's exactly what it is. Every Sprite is a persistent, fully hardware isolated linux computer with 100gb storage that only costs anything when it's actually doing something. I can have 30 projects in 30 Sprites and I'm only ever paying for the one I'm currently working on. Wrap text Copy to clipboard sprite create dashboard sprite create api-backend sprite create billion-dollar-side-project Each one has its own versions, its own serv

## How to Run Untrusted Code Safely

DevFeed: [How to Run Untrusted Code Safely](<https://devfeed.tech/articles/how-to-run-untrusted-code-safely-122062.md>)

Original publisher: [Read original article](<https://fly.io/blog/running-untrusted-code/>)

Author: Daniel Botha

Published: 2026-02-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [AI Sandbox](<https://devfeed.tech/topics/ai-sandbox.md>), [container escape](<https://devfeed.tech/topics/container-escape.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [Process](<https://devfeed.tech/topics/process.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [allowed](<https://devfeed.tech/tags/allowed.md>), [code](<https://devfeed.tech/tags/code.md>), [code-sandbox](<https://devfeed.tech/tags/code-sandbox.md>), [command-and-control](<https://devfeed.tech/tags/command-and-control.md>), [compute](<https://devfeed.tech/tags/compute.md>), [container](<https://devfeed.tech/tags/container.md>), [container-security](<https://devfeed.tech/tags/container-security.md>), [containers](<https://devfeed.tech/tags/containers.md>), [control](<https://devfeed.tech/tags/control.md>), [data](<https://devfeed.tech/tags/data.md>), [download](<https://devfeed.tech/tags/download.md>), [egress](<https://devfeed.tech/tags/egress.md>), [environment](<https://devfeed.tech/tags/environment.md>), [exploit](<https://devfeed.tech/tags/exploit.md>), [external](<https://devfeed.tech/tags/external.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [run](<https://devfeed.tech/tags/run.md>), [run-untrusted-code](<https://devfeed.tech/tags/run-untrusted-code.md>), [safely](<https://devfeed.tech/tags/safely.md>), [security](<https://devfeed.tech/tags/security.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

The excerpt argues that containers alone do not safely isolate truly untrusted code because they share the host kernel, and that filesystem isolation does not prevent outbound data theft, payload downloads, or unwanted compute use. It recommends hardware isolation, externally enforced allowlist-based network policy, rollback, and support for multiple runtimes. Its Sprites example creates a code-runner Sprite, applies a deny-all network rule through the external API (which code inside cannot change), and shows how to allow selected domains. Code can be run through a Python/Node subprocess wrapper with a 30-second timeout and exposed over HTTP. For recovery, the excerpt suggests destroying and recreating the Sprite or restoring a checkpoint; it says Sprites include several runtimes and sleep while idle. The excerpt does not show further setup details after the initial create command.

### Source excerpt

AI generates code faster than you can review it. Your agent wants to run a Python script. Your tool wants to execute user-submitted code. Your pipeline wants to test generated functions. All things you don't want to be running locally or in production unless you're just trying to add some drama to your life right now. If you want to walk the path of peace, you use a sandbox. But as any kindergartener will tell you: not all sandboxes are created equal. The Container Problem The default for the longest time has been "spin up a container." This is safer than running dodgy code on your machine. It's also not good enough. Containers share the host kernel. A kernel exploit in your untrusted code == emotional trauma. NIST SP 800-190 calls container escapes one of the most critical threats to container security. MITRE ATT&CK classifies it as technique T1611. The threat is real. Truly untrusted code needs hardware isolation. A dedicated kernel. A non-fictional boundary between the code and everything else. The Network Problem Filesystem isolation helps, but code that can't touch your files can still: Exfiltrate data to an attacker's server Download additional payloads Call out to command-and-control infrastructure Use your compute. Which isn't free Network egress control should not be considered optional. The code needs to run in an environment where outbound connections are explicitly allowed, not implicitly permitted. What You Really Need From a Sandbox Hardware isolation Network control -- allowlist-based, not denylist-based External policy enforcement -- the code can't modify its own permissions Rollback capability -- undo damage quickly when something goes wrong Multiple runtimes -- AI writes Python, JavaScript, Rust, Go, whatever Spin up and configure your sandboxes with these features and you should be safe. Or just use Sprites. Setting Up a Code Runner in a Sprite Create a Sprite for running untrusted code. Wrap text Copy to clipboard sprite create code-runner Then, lock

## Litestream Writable VFS

DevFeed: [Litestream Writable VFS](<https://devfeed.tech/articles/litestream-writable-vfs-1706.md>)

Original publisher: [Read original article](<https://fly.io/blog/litestream-writable-vfs/>)

Published: 2026-01-29T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [database](<https://devfeed.tech/tags/database.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [networking](<https://devfeed.tech/tags/networking.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [s3](<https://devfeed.tech/tags/s3.md>), [servers](<https://devfeed.tech/tags/servers.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

Litestream synchronizes SQLite databases with S3-style object storage for backup and restore. The article describes its use in Fly.io Sprites, including an orchestrator and a storage block map backed by Litestream SQLite and NVMe caching.

### Source excerpt

I'm Ben Johnson, and I work on Litestream at Fly.io. Litestream is the missing backup/restore system for SQLite. It's free, open-source software that should run anywhere, and you can read more about it here. Each time we write about it, we get a little bit better at golfing down a description of what Litestream is. Here goes: Litestream is a Unix-y tool for keeping a SQLite database synchronized with S3-style object storage. It's a way of getting the speed and simplicity wins of SQLite without exposing yourself to catastrophic data loss. Your app doesn't necessarily even need to know it's there; you can just run it as a tool in the background. It's been a busy couple weeks! We recently unveiled Sprites. If you don't know what Sprites are, you should just go check them out. They're one of the coolest things we've ever shipped. I won't waste any more time selling them to you. Just, Sprites are a big deal, and so it's a big deal to me that Litestream is a load-bearing component for them. Sprites rely directly on Litestream in two big ways. First, Litestream SQLite is the core of our global Sprites orchestrator. Unlike our flagship Fly Machines product, which relies on a centralized Postgres cluster, our Elixir Sprites orchestrator runs directly off S3-compatible object storage. Every organization enrolled in Sprites gets their own SQLite database, synchronized by Litestream. This is a fun design. It takes advantage of the "many SQLite databases" pattern, which is under-appreciated. It's got nice scaling characteristics. Keeping that Postgres cluster happy as Fly.io grew has been a major engineering challenge. But as far as Litestream is concerned, the orchestrator is boring, and so that's all I've got to say about it. The second way Sprites use Litestream is much more interesting. Litestream is built directly into the disk storage stack that runs on every Sprite. Sprites launch in under a second, and every one of them boots up with 100GB of durable storage. That's a tr

## Make Computers Make Computers

DevFeed: [Make Computers Make Computers](<https://devfeed.tech/articles/make-computers-make-computers-122059.md>)

Original publisher: [Read original article](<https://fly.io/blog/make-computers-make-computers/>)

Author: Daniel Botha

Published: 2026-01-28T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [API](<https://devfeed.tech/topics/api.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>)

Tags: [agent-delegation](<https://devfeed.tech/tags/agent-delegation.md>), [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [auth](<https://devfeed.tech/tags/auth.md>), [ci](<https://devfeed.tech/tags/ci.md>), [dev](<https://devfeed.tech/tags/dev.md>), [github](<https://devfeed.tech/tags/github.md>), [isolated-ci](<https://devfeed.tech/tags/isolated-ci.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [policies](<https://devfeed.tech/tags/policies.md>), [preview-environments](<https://devfeed.tech/tags/preview-environments.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [sprites-api](<https://devfeed.tech/tags/sprites-api.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>)

### AI overview

A Claude instance running in a Sprite can use the Sprites API to create and manage other Sprites; authorizing this control requires creating a token at sprites.dev/account/{your-org}. The excerpt describes using an Auth Sprite to manage OAuth tokens for workers, isolated per-test computers with restricted network access, and per-pull-request preview Sprites created, updated, and destroyed through GitHub webhooks. It also outlines delegating work to agents in separate Sprites with role-specific network policies, running untrusted code in a deny-all network worker, and provisioning developer environments from a reusable setup script. Controllers can checkpoint working workers and restore them before jobs. These are presented as Fly team use cases; the excerpt does not provide implementation code or measured results.

### Source excerpt

What's better than one Sprite? Sprites making other Sprites. Claude (running in a Sprite) already knows how to use the Sprites API. So you can ask it to create new Sprites, configure their network policies, hit their HTTP endpoints etc. To authorise one Sprite to control others, you'll need to visit sprites.dev/account/{your-org} and create a token. Then tell Claude to use it to authorise its Sprite. Here are a few ways that the Fly team is already using this capability on the daily: Central Auth for Everything A Sprite that handles OAuth flows for other Sprites. Say you have five Sprites that all need to talk to GitHub, Slack, or some other OAuth-protected service. Each one needs tokens. Managing that across five separate environments is annoying. Make an Auth Sprite do it for you instead. Workers call the Auth Sprite when they need a token. The Auth Sprite refreshes tokens, handles redirects and stores creds in one place. CI That Doesn't Share State Traditional CI runs tests in containers that share... something. A docker daemon. A cache directory. A network namespace. With Sprites, each test run gets its own actual computer. Tell your orchestrator Sprite to spin up a worker for each test file, lock down its network to just what it needs (pypi, github), run the test, collect results, done. Each test runs in full isolation. Nothing is shared. One flaky test can't poison another. Preview Environments Per PR Every pull request gets its own Sprite. Reviewers hit a real URL with a real running app. The orchestrator watches GitHub webhooks: PR opened -> spin up a Sprite, deploy the branch, comment the URL PR updated -> redeploy to the same Sprite PR merged/closed -> destroy the Sprite No resource contention between PRs. No "sorry, all the preview slots are taken." No shared database bleeding state between reviews. Agent Delegation You have an AI agent that's good at planning but you don't want it directly touching production. Or you have specialized agents; one that's great

## Slack Bots on Sprites: OAuth is Easy Now

DevFeed: [Slack Bots on Sprites: OAuth is Easy Now](<https://devfeed.tech/articles/slack-bots-on-sprites-oauth-is-easy-now-122063.md>)

Original publisher: [Read original article](<https://fly.io/blog/slack-bots-on-sprites/>)

Author: Daniel Botha

Published: 2026-01-27T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [Slack](<https://devfeed.tech/topics/slack.md>), [OAuth](<https://devfeed.tech/topics/oauth.md>), [hosting](<https://devfeed.tech/topics/hosting.md>), [OAuth 2.0](<https://devfeed.tech/topics/oauth2.md>)

Tags: [access-tokens](<https://devfeed.tech/tags/access-tokens.md>), [accessible](<https://devfeed.tech/tags/accessible.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [automatic](<https://devfeed.tech/tags/automatic.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [bolt](<https://devfeed.tech/tags/bolt.md>), [bot](<https://devfeed.tech/tags/bot.md>), [bots](<https://devfeed.tech/tags/bots.md>), [build](<https://devfeed.tech/tags/build.md>), [callback](<https://devfeed.tech/tags/callback.md>), [code-assistant](<https://devfeed.tech/tags/code-assistant.md>), [command](<https://devfeed.tech/tags/command.md>), [console](<https://devfeed.tech/tags/console.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [easy](<https://devfeed.tech/tags/easy.md>), [environment](<https://devfeed.tech/tags/environment.md>), [express](<https://devfeed.tech/tags/express.md>), [oauth](<https://devfeed.tech/tags/oauth.md>), [slack](<https://devfeed.tech/tags/slack.md>), [slack-bot](<https://devfeed.tech/tags/slack-bot.md>), [slack-oauth](<https://devfeed.tech/tags/slack-oauth.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

The article explains how to run a Slack bot on a Sprite, using its public URL and persistent filesystem to handle Slack OAuth callbacks and retain tokens across restarts. It walks through creating a Sprite, installing Bolt and Express, building a server on port 8080, registering it with `sprite-env services create ... --http-port 8080`, and setting a public URL and Slack app credentials. The service manager wakes the Sprite for HTTP requests, routes traffic to the specified port, and preserves service registration; idle Sprites hibernate and are said to wake in under a second. A checkpoint can snapshot the environment for restoration. The excerpt gives setup instructions but does not include the actual server implementation.

### Source excerpt

Slack bots are handy, but they typically require OAuth, which means you need a server with a public URL to handle callbacks. This is annoying. But with Sprites, you get an instant internet-accessible environment with a persistent filesystem that makes it trivial. OAuth Pain Getting your Slack bot working involves jumping through these OAuth hurdles: Create an endpoint to receive Slack's authorization callback Get that endpoint online with a public URL Securely store tokens after the callback Maintain those tokens across restarts This requires deploying something to a host, setting up Ngrok and implementing a storage solution for tokens. Slack Bot Sprites Create a Sprite for your bot: Wrap text Copy to clipboard sprite create slack-bot sprite console -s slack-bot Install your dependencies: Wrap text Copy to clipboard npm init -y npm install @slack/bolt express Build an OAuth Handler Now we need a server that: Handles the OAuth callback from Slack Stores access tokens to the filesystem Loads those tokens when the server restarts Implements your bot's functionality Ask your code assistant to: "Create a server.js file that handles Slack OAuth callbacks using the Bolt framework, stores tokens to the filesystem, and implements a simple slash command. The server should run on port 8080." Register Your Slack Bot as a Sprite Service Sprites don't use systemd or traditional init systems. Instead, they have their own service manager that enables the Sprite's automatic sleep/wake behavior. So you'll want to register your bot as a service with the HTTP port flag: Wrap text Copy to clipboard sprite-env services create slack-bot --cmd node --args server.js --http-port 8080 This does three critical things: Auto-start on HTTP requests: When a request hits your Sprite URL, the Sprite wakes from hibernation Auto-route requests: The Sprite proxy routes incoming traffic to your specified port (8080) Persistent registration: Your service registration survives Sprite restarts and hibernat

## Run OpenClaw (Formerly Moltbot and Clawdbot) in a Sprite

DevFeed: [Run OpenClaw (Formerly Moltbot and Clawdbot) in a Sprite](<https://devfeed.tech/articles/run-openclaw-formerly-moltbot-and-clawdbot-in-a-sprite-122060.md>)

Original publisher: [Read original article](<https://fly.io/blog/openclaw-in-a-sprite/>)

Author: Daniel Botha

Published: 2026-01-26T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [OpenClaw](<https://devfeed.tech/topics/openclaw.md>), [AI Sandbox](<https://devfeed.tech/topics/ai-sandbox.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [ai-assistant](<https://devfeed.tech/tags/ai-assistant.md>), [behaviour](<https://devfeed.tech/tags/behaviour.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [clawdbot](<https://devfeed.tech/tags/clawdbot.md>), [cli](<https://devfeed.tech/tags/cli.md>), [connectors](<https://devfeed.tech/tags/connectors.md>), [costs](<https://devfeed.tech/tags/costs.md>), [discord](<https://devfeed.tech/tags/discord.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [install](<https://devfeed.tech/tags/install.md>), [isolated-environment](<https://devfeed.tech/tags/isolated-environment.md>), [linux](<https://devfeed.tech/tags/linux.md>), [mac-minis](<https://devfeed.tech/tags/mac-minis.md>), [messaging](<https://devfeed.tech/tags/messaging.md>), [moltbot](<https://devfeed.tech/tags/moltbot.md>), [need](<https://devfeed.tech/tags/need.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [open-source-ai](<https://devfeed.tech/tags/open-source-ai.md>), [openclaw](<https://devfeed.tech/tags/openclaw.md>), [openclaw-sandbox](<https://devfeed.tech/tags/openclaw-sandbox.md>), [permissions](<https://devfeed.tech/tags/permissions.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

The excerpt describes running OpenClaw in a Sprite, a stateful, hardware-isolated Linux sandbox that sleeps when idle, wakes on URL requests, and preserves configuration across restarts. The setup creates a Sprite, runs OpenClaw's install wizard, registers its Gateway as a Sprite service on port 18789, and optionally makes the Sprite URL public. The wizard's systemd-unavailable and Gateway health-check errors are described as expected; the Gateway starts through Sprite's service manager. Accessing the dashboard requires copying the onboarding token and approving a pending device pairing request. A checkpoint can save the working configuration for later restoration. The excerpt ends partway through the instructions, so it does not establish full-document coverage.

### Source excerpt

Running OpenClaw on a Sprite There's zero chance this will be the first time you're hearing about OpenClaw, the project previously known as Clawdbot and then Moltbot. It's an open-source AI assistant that connects to messaging platforms you probably already use: WhatsApp, Telegram, Slack, Discord, Signal, etc. It comes with a fast-growing list of connectors and Skills and self-iterating capabilities, right out of the box. If you really want to see what a project like OpenClaw can do, you need to run it with generous permissions and give it access to its environment. That is inherently scary, which is why so many people have been snapping up Mac Minis to run their OpenClaw in an isolated environment. You don't need a Mac Mini. Instead, let's learn how to run OpenClaw in a Sprite. (Prefer one click? Deploy OpenClaw on a Sprite and skip the rest of this post.) A stateful sandbox with automatic sleep/wake behaviour that keeps running costs low. Sprites are fully hardware isolated Linux computers, so you can give OpenClaw total agency and not even have to think about building your own guardrails. Create a Sprite Install the Sprites CLI and create a Sprite: Wrap text Copy to clipboard curl -fsSL https://sprites.dev/install.sh | bash sprite create openclaw Connect to the Sprite console: Wrap text Copy to clipboard sprite console -s openclaw Install and Configure OpenClaw Run the OpenClaw install script: Wrap text Copy to clipboard curl -fsSL https://openclaw.ai/install.sh | bash The wizard will configure your credentials, hooks, and messaging platforms. You'll see two expected errors at the end: Systemd unavailable -- Sprites don't use systemd Health check failed -- The Gateway isn't running yet This is normal. The onboarding creates your config. We'll start the Gateway next. Important: Copy the token shown in OpenClaw's output. It looks like: 9054a0cfca3f5be5325f988fb57ddf1f38e530d2883bbed7 Add openclaw to your PATH so it's available in future sessions: Wrap text Copy to cl

## Run Claude Code From Your Phone With Sprites

DevFeed: [Run Claude Code From Your Phone With Sprites](<https://devfeed.tech/articles/run-claude-code-from-your-phone-with-sprites-122056.md>)

Original publisher: [Read original article](<https://fly.io/blog/how-sprites-accidentally-solved-mobile-development/>)

Author: Daniel Botha

Published: 2026-01-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [AI Sandbox](<https://devfeed.tech/topics/ai-sandbox.md>), [PWA](<https://devfeed.tech/topics/pwa.md>)

Tags: [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [claude-code-mobile](<https://devfeed.tech/tags/claude-code-mobile.md>), [claude-code-on-phone](<https://devfeed.tech/tags/claude-code-on-phone.md>), [code](<https://devfeed.tech/tags/code.md>), [code-assistant](<https://devfeed.tech/tags/code-assistant.md>), [code-from-phone](<https://devfeed.tech/tags/code-from-phone.md>), [coding](<https://devfeed.tech/tags/coding.md>), [environment](<https://devfeed.tech/tags/environment.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [file](<https://devfeed.tech/tags/file.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [idea](<https://devfeed.tech/tags/idea.md>), [ideas](<https://devfeed.tech/tags/ideas.md>), [linux](<https://devfeed.tech/tags/linux.md>), [mac](<https://devfeed.tech/tags/mac.md>), [machine](<https://devfeed.tech/tags/machine.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [packages](<https://devfeed.tech/tags/packages.md>), [phone](<https://devfeed.tech/tags/phone.md>), [project](<https://devfeed.tech/tags/project.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [sprites](<https://devfeed.tech/tags/sprites.md>), [the-fly-blog](<https://devfeed.tech/tags/the-fly-blog.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

The excerpt describes using Sprites as on-demand Linux computers for running Claude Code from a phone. A Sprite starts in under a second, retains code, packages, and project state while suspended, and can be checkpointed as a restorable snapshot of the full environment. The suggested setup creates a Sprite, runs the sprite-mobile install script to configure authentication, Tailscale, and the mobile chat interface, then publishes a URL for access from a Tailscale-connected phone. Sprites are said to sleep after 30 seconds of inactivity and incur charges only while actively using resources. These are claims in the supplied excerpt; it does not provide independent evaluation or full setup details.

### Source excerpt

A few days ago, this post hit HN's front page and generated over 400 comments. The author is talking about the setup he uses to code from his phone using Tailscale, an always-on Mac at home, SSH via Termius, and Claude Code in the terminal. If you're asking why anyone would want to code from their phone, you can safely stop reading now and return to a peaceful existence, where ideas only come to you when you're sitting behind a computer. For those familiar with the need to try an idea right now, wherever you are, whatever you're doing, you're in the right place. What Was and Need No Longer Be The HN post's comments section showed off some genuinely impressive mobile coding setups that range from the creative to the absurdly over-engineered. Tmux sessions, VPS boxes, all the SSH clients, and a million ways to access these env's from your phone. For a lot of people, designing setups like this is fun. But if managing always-on servers and VPN configurations is less exciting to you than building an app in real time while brainstorming it on a hiking trail, there's a better way. We call 'em Sprites. What's a Sprite Again? The correct answer is: Whatever you want it to be. But that isn't super helpful in this context. So let's start with the idea of a Sprite as the server in your mobile coding setup. Instead of running a machine 24/7 or starting and stopping a VM, use a Sprite. It's a full Linux computer that spins up in under a second and runs only when you need it. Your code, installed packages, and project state persist between sessions, even when the Sprite is suspended. You (or Claude) can checkpoint your Sprite at any time, which creates a restorable snapshot of the entire environment, not just your code. And since it's a hardware-isolated computer rather than a shared container, you can run literally any code and experiment aggressively, while genuinely just not caring about breaking anything important. If you want to unleash your code assistant, give it full file

## The Design & Implementation of Sprites

DevFeed: [The Design & Implementation of Sprites](<https://devfeed.tech/articles/the-design-implementation-of-sprites-1694.md>)

Original publisher: [Read original article](<https://fly.io/blog/design-and-implementation/>)

Published: 2026-01-14T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [fly.io](<https://devfeed.tech/topics/fly-io.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [ssh](<https://devfeed.tech/topics/ssh.md>), [container](<https://devfeed.tech/topics/container.md>), [Docker](<https://devfeed.tech/topics/docker.md>)

Tags: [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-computing](<https://devfeed.tech/tags/cloud-computing.md>), [containers](<https://devfeed.tech/tags/containers.md>), [cost](<https://devfeed.tech/tags/cost.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [linux](<https://devfeed.tech/tags/linux.md>), [networking](<https://devfeed.tech/tags/networking.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [platform](<https://devfeed.tech/tags/platform.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [scale](<https://devfeed.tech/tags/scale.md>), [servers](<https://devfeed.tech/tags/servers.md>), [ssh](<https://devfeed.tech/tags/ssh.md>)

### AI overview

Fly.io's article introduces Sprites, disposable Linux virtual machines designed to start in seconds, provide root access and a durable 100GB filesystem, and automatically sleep when inactive. It explains the orchestration decisions behind the platform, including moving away from container images while retaining convenient, Docker-like workflows.

### Source excerpt

We're Fly.io, and this is the place in the post where we'd normally tell you that our job is to take your containers and run them on our own hardware all around the world. But last week, we launched Sprites, and they don't work that way at all. Sprites are something new: Docker without Docker without Docker. This post is about how they work. Replacement-level homeowners buy boxes of pens and stick them in "the pen drawer". What the elites know: you have to think adversarially about pens. "The purpose of a system is what it does"; a household's is to uniformly distribute pens. Months from now, the drawer will be empty, no matter how many pens you stockpile. Instead, scatter pens every place you could possibly think to look for one -- drawers, ledges, desks. Any time anybody needs a pen, several are at hand, in exactly the first place they look. This is the best way I've found to articulate the idea of Sprites, the platform we just launched at Fly.io. Sprites are ball-point disposable computers. Whatever mark you mean to make, we've rigged it so you're never more than a second or two away from having a Sprite to do it with. Sprites are Linux virtual machines. You get root. They create in just a second or two: so fast, the experience of creating and shelling into one is identical to SSH'ing into a machine that already exists. Sprites all have a 100GB durable root filesystem. They put themselves to sleep automatically when inactive, and cost practically nothing while asleep. As a result, I barely feel the need to name my Sprites. Sometimes I'll just type sprite create dkjsdjk and start some task. People at Fly.io who use Sprites have dozens hanging around. There aren't yet many things in cloud computing that have the exact shape Sprites do: Instant creation No time limits Persistent disk Auto-sleep to a cheap inactive state This is a post about how we managed to get this working. We created a new orchestration stack that undoes some of the core decisions we made for Fly

## Code And Let Live

DevFeed: [Code And Let Live](<https://devfeed.tech/articles/code-and-let-live-1691.md>)

Original publisher: [Read original article](<https://fly.io/blog/code-and-let-live/>)

Published: 2026-01-09T00:00:00Z

Content type: opinion

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [Cloud](<https://devfeed.tech/topics/cloud.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [apt](<https://devfeed.tech/topics/apt.md>), [Amazon EC2](<https://devfeed.tech/topics/amazon-ec2.md>), [Network](<https://devfeed.tech/topics/network.md>), [ssh](<https://devfeed.tech/topics/ssh.md>), [Docker](<https://devfeed.tech/topics/docker.md>)

Tags: [apt](<https://devfeed.tech/tags/apt.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [code](<https://devfeed.tech/tags/code.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [linux](<https://devfeed.tech/tags/linux.md>), [network](<https://devfeed.tech/tags/network.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [ssh](<https://devfeed.tech/tags/ssh.md>)

### AI overview

Fly.io presents Sprites as durable, rapidly created cloud computers designed to replace ephemeral, read-only sandboxes. A Sprite provides a persistent Linux environment with substantial storage, automatic sleep, checkpoint and restore, networking, and low-cost operation at scale.

### Source excerpt

The state of the art in agent isolation is a read-only sandbox. At Fly.io, we've been selling that story for years, and we're calling it: ephemeral sandboxes are obsolete. Stop killing your sandboxes every time you use them. My argument won't make sense without showing you something new we've built. We're all adults here, this is a company, we talk about what we do. Here goes. So, I want to run some code. So what I do is, I run sprite create. While it operates, I'll explain what's happening behind the-- Wrap text Copy to clipboard ✓ Created demo-123 sprite in 1.0s ● Connecting to console... sprite@sprite:~# Shit, it's already there. That's a root shell on a Linux computer we now own. It came online in about the same amount of time it would take to ssh into a host that already existed. We call these things "Sprites". Let's install FFmpeg on our Sprite: Wrap text Copy to clipboard sudo apt-get install -y ffmpeg >/dev/null 2>&1 Unlike creating the Sprite in the first place, installing ffmpeg with apt-get is dog slow. Let's try not to have to do that again: Wrap text Copy to clipboard sprite@sprite:~# sprite-env checkpoints create # ... {"type":"complete","data":"Checkpoint v1 created successfully", "time":"2025-12-22T22:50:48.60423809Z"} This completes instantly. Didn't even bother to measure. I step away to get coffee. Time passes. The Sprite, noticing my inactivity, goes to sleep. I meet an old friend from high school at the coffee shop. End up spending the day together. More time passes. Days even. Returning later: Wrap text Copy to clipboard > $ sprite console sprite@sprite:~# ffmpeg ffmpeg version 7.1.1-1ubuntu1.3 Copyright (c) 2000-2025 the FFmpeg developers Use -h to get full help or, even better, run 'man ffmpeg' sprite@sprite:~# Everything's where I left it. Sprites are durable. 100GB capacity to start, no ceremony. Maybe I'll keep it around a few more days, maybe a few months, doesn't matter, just works. Say I get an application up on its legs. Install more pa

## Litestream VFS

DevFeed: [Litestream VFS](<https://devfeed.tech/articles/litestream-vfs-1705.md>)

Original publisher: [Read original article](<https://fly.io/blog/litestream-vfs/>)

Published: 2025-12-11T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [Database](<https://devfeed.tech/topics/database.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [software-development](<https://devfeed.tech/topics/software-development.md>)

Tags: [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [database](<https://devfeed.tech/tags/database.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [dev](<https://devfeed.tech/tags/dev.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [networking](<https://devfeed.tech/tags/networking.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [open-source-software](<https://devfeed.tech/tags/open-source-software.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [s3](<https://devfeed.tech/tags/s3.md>), [servers](<https://devfeed.tech/tags/servers.md>), [sql](<https://devfeed.tech/tags/sql.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>)

### AI overview

The article introduces Litestream VFS, which lets SQLite query Litestream-backed databases directly from object storage such as Amazon S3. It supports querying without downloading the entire database and provides SQL- and pragma-based point-in-time recovery. The article also explains how Litestream v0.5 uses LTX ordered page sets and compaction to restore the latest versions of changed database pages efficiently.

### Source excerpt

I'm Ben Johnson, and I work on Litestream at Fly.io. Litestream is the missing backup/restore system for SQLite. It's free, open-source software that should run anywhere, and you can read more about it here. Again with the sandwiches: assume we've got a SQLite database of sandwich ratings, and we've backed it up with Litestream to an S3 bucket. Now, on our local host, load up AWS credentials and an S3 path into our environment. Open SQLite and: Wrap text Copy to clipboard $ sqlite3 SQLite version 3.50.4 2025-07-30 19:33:53 sqlite> .load litestream.so sqlite> .open file:///my.db?vfs=litestream SQLite is now working from that remote database, defined by the Litestream backup files in the S3 path we configured. We can query it: Wrap text Copy to clipboard sqlite> SELECT * FROM sandwich_ratings ORDER BY RANDOM() LIMIT 3 ; 22|Veggie Delight|New York|4 30|Meatball|Los Angeles|5 168|Chicken Shawarma Wrap|Detroit|5 This is Litestream VFS. It runs SQLite hot off an object storage URL. As long as you can load the shared library our tree builds for you, it'll work in your application the same way it does in the SQLite shell. Fun fact: we didn't have to download the whole database to run this query. More about this in a bit. Meanwhile, somewhere in prod, someone has it in for meatball subs and wants to knock them out of the bracket - oh, fuck: Wrap text Copy to clipboard sqlite> UPDATE sandwich_ratings SET stars = 1 ; They forgot the WHERE clause! Wrap text Copy to clipboard sqlite> SELECT * FROM sandwich_ratings ORDER BY RANDOM() LIMIT 3 ; 97|French Dip|Los Angeles|1 140|Bánh Mì|San Francisco|1 62|Italian Beef|Chicago|1 Italian Beefs and Bánh Mìs, all at 1 star. Disaster! But wait, back on our dev machine: Wrap text Copy to clipboard sqlite> PRAGMA litestream_time = '5 minutes ago'; sqlite> select * from sandwich_ratings ORDER BY RANDOM() LIMIT 3 ; 30|Meatball|Los Angeles|5 33|Ham & Swiss|Los Angeles|2 163|Chicken Shawarma Wrap|Detroit|5 We're now querying that database from a

## You Should Write An Agent

DevFeed: [You Should Write An Agent](<https://devfeed.tech/articles/you-should-write-an-agent-1695.md>)

Original publisher: [Read original article](<https://fly.io/blog/everyone-write-an-agent/>)

Published: 2025-11-06T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [API](<https://devfeed.tech/topics/api.md>), [OpenAI](<https://devfeed.tech/topics/openai.md>), [Code](<https://devfeed.tech/topics/code.md>), [context window](<https://devfeed.tech/topics/context-window.md>), [ChatGPT](<https://devfeed.tech/topics/chatgpt.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [api](<https://devfeed.tech/tags/api.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [chatgpt](<https://devfeed.tech/tags/chatgpt.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [code](<https://devfeed.tech/tags/code.md>), [context-window](<https://devfeed.tech/tags/context-window.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [docker](<https://devfeed.tech/tags/docker.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [networking](<https://devfeed.tech/tags/networking.md>), [openai](<https://devfeed.tech/tags/openai.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [tool](<https://devfeed.tech/tags/tool.md>)

### AI overview

The article argues that developers should write an LLM agent to understand the technology through practice. It presents a small Python engine for an LLM application using the OpenAI Responses API, showing how a terminal conversation can reproduce ChatGPT-like behavior, maintain a context window, and add tool use.

### Source excerpt

Some concepts are easy to grasp in the abstract. Boiling water: apply heat and wait. Others you really need to try. You only think you understand how a bicycle works, until you learn to ride one. There are big ideas in computing that are easy to get your head around. The AWS S3 API. It's the most important storage technology of the last 20 years, and it's like boiling water. Other technologies, you need to get your feet on the pedals first. LLM agents are like that. People have wildly varying opinions about LLMs and agents. But whether or not they're snake oil, they're a big idea. You don't have to like them, but you should want to be right about them. To be the best hater (or stan) you can be. So that's one reason you should write an agent. But there's another reason that's even more persuasive, and that's It's Incredibly Easy Agents are the most surprising programming experience I've had in my career. Not because I'm awed by the magnitude of their powers -- I like them, but I don't like-like them. It's because of how easy it was to get one up on its legs, and how much I learned doing that. I'm about to rob you of a dopaminergic experience, because agents are so simple we might as well just jump into the code. I'm not even going to bother explaining what an agent is. Wrap text Copy to clipboard from openai import OpenAI client = OpenAI() context = [] def call(): return client.responses.create(model="gpt-5", input=context) def process(line): context.append({"role": "user", "content": line}) response = call() context.append({"role": "assistant", "content": response.output_text}) return response.output_text It's an HTTP API with, like, one important endpoint. This is a trivial engine for an LLM app using the OpenAI Responses API. It implements ChatGPT. You'd drive it with the the obvious loop. It'll do what you'd expect: the same thing ChatGPT would, but in your terminal. Wrap text Copy to clipboard def main(): while True: line = input("&gt; ") result = process(line) p

## Corrosion

DevFeed: [Corrosion](<https://devfeed.tech/articles/corrosion-1692.md>)

Original publisher: [Read original article](<https://fly.io/blog/corrosion/>)

Published: 2025-10-22T00:00:00Z

Content type: article

Language: en

Sources: [Fly](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Network](<https://devfeed.tech/topics/network.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>)

Tags: [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [distributed-system](<https://devfeed.tech/tags/distributed-system.md>), [docker](<https://devfeed.tech/tags/docker.md>), [docker-containers](<https://devfeed.tech/tags/docker-containers.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [heroku-alternative](<https://devfeed.tech/tags/heroku-alternative.md>), [heroku-competitor](<https://devfeed.tech/tags/heroku-competitor.md>), [hosting](<https://devfeed.tech/tags/hosting.md>), [i](<https://devfeed.tech/tags/i.md>), [networking](<https://devfeed.tech/tags/networking.md>), [outage](<https://devfeed.tech/tags/outage.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [routing](<https://devfeed.tech/tags/routing.md>), [rust](<https://devfeed.tech/tags/rust.md>), [servers](<https://devfeed.tech/tags/servers.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>)

### AI overview

This article introduces Corrosion, Fly.io's open-source distributed state synchronization and service discovery system. It explains how Fly.io propagates workload and routing state across globally distributed servers and edge proxies, and recounts a severe outage caused by a Rust concurrency bug that triggered a contagious deadlock. The article also describes Fly.io's decentralized orchestration model, in which individual servers are authoritative for their workloads instead of relying on a centralized database.

### Source excerpt

Fly.io transmogrifies Docker containers into Fly Machines: micro-VMs running on our own hardware all over the world. The hardest part of running this platform isn't managing the servers, and it isn't operating the network; it's gluing those two things together. Several times a second, as customer CI/CD pipelines tear up or bring down Fly Machines, our state synchronization system blasts updates across our internal mesh, so that edge proxies from Tokyo to Amsterdam can keep the accurate routing table that allows them to route requests for applications to the nearest customer instances. On September 1, 2024, at 3:30PM EST, a new Fly Machine came up with a new "virtual service" configuration option a developer had just shipped. Within a few seconds every proxy in our fleet had locked up hard. It was the worst outage we've experienced: a period during which no end-user requests could reach our customer apps at all. Distributed systems are blast amplifiers. By propagating data across a network, they also propagate bugs in the systems that depend on that data. In the case of Corrosion, our state distribution system, those bugs propagate quickly. The proxy code that handled that Corrosion update had succumbed to a notorious Rust concurrency footgun: an if let expression over an RWLock assumed (reasonably, but incorrectly) in its else branch that the lock had been released. Instant and virulently contagious deadlock. A lesson we've learned the hard way: never trust a distributed system without an interesting failure story. If a distributed system hasn't ruined a weekend or kept you up overnight, you don't understand it yet. Which is why that's how we're introducing Corrosion, an unconventional service discovery system we built for our platform and open sourced. Our Face-Seeking Rake State synchronization is the hardest problem in running a platform like ours. So why build a risky new distributed system for it? Because no matter what we try, that rake is waiting for our foot

[Next page](<https://devfeed.tech/sources/the-fly-blog.md?cursor=WyIyMDI1LTEwLTIyVDAwOjAwOjAwKzAwOjAwIiwgImE1MTBlMTg5LTgwMGUtNGFkMC1hMzZmLTRkMzI4MGEyM2U3ZiJd>)