# deploy app servers

Published articles for deploy app servers.

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

## 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: [The Fly Blog](<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: [The Fly Blog](<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: [The Fly Blog](<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

## 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: [The Fly Blog](<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

## 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: [The Fly Blog](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [fly.io](<https://devfeed.tech/topics/fly-io.md>), [fly](<https://devfeed.tech/topics/fly.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>), [Containers](<https://devfeed.tech/topics/containers.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: [The Fly Blog](<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: [The Fly Blog](<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>), [Databases](<https://devfeed.tech/topics/databases.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Development](<https://devfeed.tech/topics/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: [The Fly Blog](<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: [The Fly Blog](<https://devfeed.tech/sources/the-fly-blog.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.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](<https://devfeed.tech/topics/fly.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

## Kurt Got Got

DevFeed: [Kurt Got Got](<https://devfeed.tech/articles/kurt-got-got-1701.md>)

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

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

Content type: article

Language: en

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

Topics: [fly.io](<https://devfeed.tech/topics/fly-io.md>), [X (Twitter)](<https://devfeed.tech/topics/twitter.md>), [vulnerability](<https://devfeed.tech/topics/vulnerability.md>), [Exploit](<https://devfeed.tech/topics/exploit.md>)

Tags: [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>), [developer](<https://devfeed.tech/tags/developer.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>), [phishing](<https://devfeed.tech/tags/phishing.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

Fly.io describes how its CEO was phished, leading to an account takeover of the company's Twitter/X account. The attack exploited social-engineering cues related to the company's use of developer memes, and the team responded by auditing access to login credentials in 1Password and removing recent access.

### Source excerpt

The $FLY Airdrop is live! Claim your share of the token powering Fly.io's global network of 3M+ apps and (🤮) own a piece of the sky! We know. Our Twitter got owned. We knew within moments of it happening. We know exactly how it happened. Nothing was at risk other than our Twitter account (and one Fly.io employee's self-esteem). Also: for fuck's sake. Here's what happened: Kurt Mackey, our intrepid CEO, got phished. Had this been an impactful attack, we would not be this flippant about it. For this, though, any other tone on our part would be false. How They Got Kurt Two reasons: one, it was a pretty good phishing attack, and two, Twitter fell outside the "things we take seriously" boundary. The phishing attack was effective because it exploited a deep psychological vulnerability in our management team: we are old and out of touch with the youths of today. For many months now, we've had an contractor/intern-type-person Boosting Our Brand on Twitter by posting dank developer memes (I think that's what they're called). The thing about this dankery is that we don't really understand it. I mean, hold on, we know what the memes mean technically. We just don't get why they're funny. However, in pushing back on them, we're up against two powerful forces: The dank memes appear to perform better than the stuff we ourselves write on Twitter. We are reliably informed by our zoomer children that we are too cringe to be trusted on these matters. Here's the phish Kurt got: Diabolical. Like a scalpel expertly wielded against Kurt's deepest middle-aged-dude insecurity. Our ruthless attackers clinically designed this email to trigger an autonomic Kurt response: "oh, what the fuck is this, and why did we post it?" ATO is cool-kid for "got owned" I'm getting a little ahead of the story here. We knew our X.com account had suffered an ATO because a bunch of us simultaneously got another email saying that the @flydotio account's email address now pointed to achilles19969@gmail.com. Our im

## Litestream v0.5.0 is Here

DevFeed: [Litestream v0.5.0 is Here](<https://devfeed.tech/articles/litestream-v0-5-0-is-here-1704.md>)

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

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

Content type: release

Language: en

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

Topics: [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [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>), [deployment](<https://devfeed.tech/tags/deployment.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](<https://devfeed.tech/tags/open-source.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [replication](<https://devfeed.tech/tags/replication.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [servers](<https://devfeed.tech/tags/servers.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [streaming](<https://devfeed.tech/tags/streaming.md>)

### AI overview

Litestream v0.5.0 is a faster open-source backup and restore system for SQLite applications. The update adds efficient point-in-time recovery and incorporates lessons from LiteFS, while Litestream continues streaming SQLite WAL checkpoints to object storage in real time.

### Source excerpt

I'm Ben Johnson, and I work on Litestream at Fly.io. Litestream makes it easy to build SQLite-backed full-stack applications with resilience to server failure. It's open source, runs anywhere, and it's easy to get started. Litestream is the missing backup/restore system for SQLite. It runs as a sidecar process in the background, alongside unmodified SQLite applications, intercepting WAL checkpoints and streaming them to object storage in real time. Your application doesn't even know it's there. But if your server crashes, Litestream lets you quickly restore the database to your new hardware. The result: you can safely build whole full-stack applications on top of SQLite. A few months back, we announced plans for a major update to Litestream. I'm psyched to announce that the first batch of those changes are now "shipping". Litestream is faster and now supports efficient point-in-time recovery (PITR). I'm going to take a beat to recap Litestream and how we got here, then talk about how these changes work and what you can expect to see with them. Litestream to LiteFS to Litestream Litestream is one of two big SQLite things I've built. The other one, originally intended as a sort of sequel to Litestream, is LiteFS. Boiled down to a sentence: LiteFS uses a FUSE filesystem to crawl further up into SQLite's innards, using that access to perform live replication, for unmodified SQLite-backed apps. The big deal about LiteFS for us is that it lets you do the multiregion primary/read-replica deployment people love Postgres for: reads are fast everywhere, and writes are sane and predictable. We were excited to make this possible for SQLite, too. But the market has spoken! Users prefer Litestream. And honestly, we get it: Litestream is easier to run and to reason about. So we've shifted our focus back to it. First order of business: take what we learned building LiteFS and stick as much of it as we can back into Litestream. The LTX File Format Consider this basic SQL table: Wrap

## Build Better Agents With MorphLLM

DevFeed: [Build Better Agents With MorphLLM](<https://devfeed.tech/articles/build-better-agents-with-morphllm-1689.md>)

Original publisher: [Read original article](<https://fly.io/blog/build-better-agents-with-morphllm/>)

Published: 2025-08-25T00:00:00Z

Content type: article

Language: en

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

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Code](<https://devfeed.tech/topics/code.md>), [developer velocity](<https://devfeed.tech/topics/developer-velocity.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [code](<https://devfeed.tech/tags/code.md>), [cost](<https://devfeed.tech/tags/cost.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [developer-velocity](<https://devfeed.tech/tags/developer-velocity.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>), [hallucinations](<https://devfeed.tech/tags/hallucinations.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>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

The article presents MorphLLM's Morph Fast Apply as a semantic, structure-aware code-editing tool for AI agents. It addresses the inefficiency and unreliability of full-file rewrites by enabling precise, context-aware edits that reduce token use, compute, cost, and time.

### Source excerpt

I'm an audiophile, which is a nice way to describe someone who spends their children's college fund on equipment that yields no audible improvement in sound quality. As such, I refused to use wireless headphones for the longest time. The fun thing about wired headphones is when you forget they're on and you stand up, you simultaneously cause irreparable neck injuries and extensive property damage. This eventually prompted me to buy good wireless headphones and, you know what, I break fewer things now. I can also stand up from my desk and not be exposed to the aural horrors of the real world. This is all to say, sometimes you don't know how big a problem is until you solve it. This week, I chatted to the fine people building MorphLLM, which is exactly that kind of solution for AI agent builders. Slow, Wasteful and Expensive AI Code Changes If you're building AI agents that write or edit code, you're probably accepting the following as "the way it is": Your agent needs to correct a single line of code, but rewrites an entire file to do it. Search-and-replace right? It's fragile, breaks formatting, silently fails, or straight up leaves important functions out. The result is slow, inaccurate code changes, excessive token use, and an agent feels incompetent and unreliable. Full file rewrites are context-blind and prone to hallucinations, especially when editing that 3000+ line file that you've been meaning to refactor. And every failure and iteration is wasted compute, wasted money and worst of all, wasted time. Why We Aren't Thinking About This (or why I wasn't) AI workflows are still new to everyone. Best practices are still just opinions and most tooling is focused on model quality, not developer velocity or cost. This is a big part of why we feel that slow, wasteful code edits are just the price of admission for AI-powered development. In reality, these inefficiencies become a real bottleneck for coding agent tools. The hidden tax on every code edit adds up and your

## Trust Calibration for AI Software Builders

DevFeed: [Trust Calibration for AI Software Builders](<https://devfeed.tech/articles/trust-calibration-for-ai-software-builders-1721.md>)

Original publisher: [Read original article](<https://fly.io/blog/trust-calibration-for-ai-software-builders/>)

Published: 2025-08-18T00:00:00Z

Content type: article

Language: en

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

Topics: [Interaction Design](<https://devfeed.tech/topics/interaction-design.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [cursor](<https://devfeed.tech/topics/cursor.md>), [Software](<https://devfeed.tech/topics/software.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [article](<https://devfeed.tech/tags/article.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [code](<https://devfeed.tech/tags/code.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>), [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>), [interaction-design](<https://devfeed.tech/tags/interaction-design.md>), [mental-models](<https://devfeed.tech/tags/mental-models.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](<https://devfeed.tech/tags/software.md>)

### AI overview

The article explains trust calibration for AI software products: aligning users' trust with a system's actual capabilities and limitations. It discusses the risks of over-trust and under-trust, advocates accurate user mental models, and uses Cursor's change highlighting as an example of communicating that model-generated code is a suggestion rather than a command.

### Source excerpt

Trust calibration is a concept from the world of human-machine interaction design, one that is super relevant to AI software builders. Trust calibration is the practice of aligning the level of trust that users have in our products with its actual capabilities. If we build things that our users trust too blindly, we risk facilitating dangerous or destructive interactions that can permanently turn users off. If they don't trust our product enough, it will feel useless or less capable than it actually is. So what does trust calibration look like in practice and how do we achieve it? A 2023 study reviewed over 1000 papers on trust and trust calibration in human / automated systems (properly referenced at the end of this article). It holds some pretty eye-opening insights - and some inconvenient truths - for people building AI software. I've tried to extract just the juicy bits below. Limiting Trust Let's begin with a critical point. There is a limit to how deeply we want users to trust our products. Designing for calibrated trust is the goal, not more trust at any cost. Shoddy trust calibration leads to two equally undesirable outcomes: Over-trust causes users to rely on AI systems in situations where they shouldn't (I told my code assistant to fix a bug in prod and went to bed). Under-trust causes users to reject AI assistance even when it would be beneficial, resulting in reduced perception of value and increased user workload. What does calibrated trust look like for your product? It's important to understand that determining this is less about trying to diagram a set of abstract trust parameters and more about helping users develop accurate mental models of your product's capabilities and limitations. In most cases, this requires thinking beyond the trust calibration mechanisms we default to, like confidence scores. For example, Cursor's most prominent trust calibration mechanism is its change suggestion highlighting. The code that the model suggests we change is h

## Games as Model Eval: 1-Click Deploy AI Town on Fly.io

DevFeed: [Games as Model Eval: 1-Click Deploy AI Town on Fly.io](<https://devfeed.tech/articles/games-as-model-eval-1-click-deploy-ai-town-on-fly-io-1698.md>)

Original publisher: [Read original article](<https://fly.io/blog/games-as-model-eval/>)

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

Content type: opinion

Language: en

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

Topics: [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Kaggle](<https://devfeed.tech/topics/kaggle.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>)

Tags: [ai-models](<https://devfeed.tech/tags/ai-models.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.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>), [eval](<https://devfeed.tech/tags/eval.md>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [games](<https://devfeed.tech/tags/games.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>)

### AI overview

The article argues that games can make AI model evaluation more rigorous and engaging. It highlights the limits of conventional benchmarks and subjective output comparisons, points to Google's Kaggle Game Arena, and presents game environments as tests of strategic reasoning, long-term planning, and dynamic adaptation.

### Source excerpt

Recently, I suggested that The Future Isn't Model Agnostic, that it's better to pick one model that works for your project and build around it, rather than engineering for model flexibility. If you buy that, you also have to acknowledge how important comprehensive model evaluation becomes. Benchmarks tell us almost nothing about how a model will actually behave in the wild, especially with long contexts, or when trusted to deliver the tone and feel that defines the UX we're shooting for. Even the best evaluation pipelines usually end in subjective, side-by-side output comparisons. Not especially rigorous, and more importantly, boring af. Can we gamify model evaluation? Oh yes. And not just because we get to have some fun for once. Google backed me up this week when it announced the Kaggle Game Arena. A public platform where we can watch AI models duke it out in a variety of classic games. Quoting Google; "Current AI benchmarks are struggling to keep pace with modern models... it can be hard to know if models trained on internet data are actually solving problems or just remembering answers they've already seen." When models boss reading comprehension tests, or ace math problems, we pay attention. But when they fail to navigate a simple conversation with a virtual character or completely botch a strategic decision in a game environment, we tell ourselves we're not building a game anyway and develop strategic short-term memory loss. Just like I've told my mom a thousand times, games are great at testing brains, and it's time we take this seriously when it comes to model evaluation. Why Games Don't Lie Games provide what benchmarks can't, "a clear, unambiguous signal of success." They give us observable behavior in dynamic environments, the kind that would be extremely difficult (and tedious) to simulate with prompt engineering alone. Games force models to demonstrate the skills we actually care about; strategic reasoning, long-term planning, and dynamic adaptation in in

## The Future Isn't Model Agnostic

DevFeed: [The Future Isn't Model Agnostic](<https://devfeed.tech/articles/the-future-isn-t-model-agnostic-1720.md>)

Original publisher: [Read original article](<https://fly.io/blog/the-future-isn-t-model-agnostic/>)

Published: 2025-08-08T00:00:00Z

Content type: opinion

Language: en

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

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

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.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>), [llms](<https://devfeed.tech/tags/llms.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [model](<https://devfeed.tech/tags/model.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [product](<https://devfeed.tech/tags/product.md>), [qwen](<https://devfeed.tech/tags/qwen.md>), [servers](<https://devfeed.tech/tags/servers.md>)

### AI overview

The article argues that model agnosticism is a poor priority as LLM capabilities converge. It says durable AI products come from understanding a chosen model and designing reliable workflows and user experiences around it, using Claude Code's user loyalty despite Qwen 3 Coder's benchmark advantage as an example.

### Source excerpt

Your users don't care that your AI project is model agnostic. In my last project, I spent countless hours ensuring that the LLMs running my services could be swapped out as easily as possible. I couldn't touch a device with an internet connection without hearing about the latest benchmark-breaking model and it felt like a clear priority to ensure I could hot swap models with minimal collateral damage. So yeah. That was a waste of time. The hype around new model announcements feels more manufactured with each release. In reality, improvements are becoming incremental. As major providers converge on the same baseline, the days of one company holding a decisive lead are numbered. In a world of model parity, the differentiation moves entirely to the product layer. Winning isn't about ensuring you're using the best model, its about understanding your chosen model deeply enough to build experiences that feel magical. Knowing exactly how to prompt for consistency, which edge cases to avoid, and how to design workflows that play to your model's particular strengths Model agnosticism isn't just inefficient, it's misguided. Fact is, swapping out your model is not just changing an endpoint. It's rewriting prompts, rerunning evals, users telling you things just feel... different. And if you've won users on the way it feels to use your product, that last one is a really big deal. Model < Product Recently, something happened that fully solidified this idea in my head. Claude Code is winning among people building real things with AI. We even have evangelists in the Fly.io engineering team, and those guys are weird smart. Elsewhere, whole communities have formed to share and compare claude.md's and fight each other over which MCP servers are the coolest to use with Claude. Enter stage right, Qwen 3 Coder. It takes Claude to the cleaners in benchmarks. But the response from the Claude Code user base? A collective meh. This is nothing like 2024, when everyone would have dropped everyth

## Phoenix.new - The Remote AI Runtime for Phoenix

DevFeed: [Phoenix.new - The Remote AI Runtime for Phoenix](<https://devfeed.tech/articles/phoenix-new-the-remote-ai-runtime-for-phoenix-1715.md>)

Original publisher: [Read original article](<https://fly.io/blog/phoenix-new-the-remote-ai-runtime/>)

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

Content type: article

Language: en

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

Topics: [phoenix](<https://devfeed.tech/topics/phoenix.md>), [Elixir](<https://devfeed.tech/topics/elixir.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [coding](<https://devfeed.tech/topics/coding.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>), [fly](<https://devfeed.tech/topics/fly.md>), [browser](<https://devfeed.tech/topics/browser.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [Front end](<https://devfeed.tech/topics/frontend.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [browser](<https://devfeed.tech/tags/browser.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.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>), [javascript](<https://devfeed.tech/tags/javascript.md>), [networking](<https://devfeed.tech/tags/networking.md>), [phoenix](<https://devfeed.tech/tags/phoenix.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [servers](<https://devfeed.tech/tags/servers.md>), [vscode](<https://devfeed.tech/tags/vscode.md>)

### AI overview

Phoenix.new is a fully online coding agent tailored to Elixir and Phoenix. It runs in a browser-backed, isolated Fly Machine with shell access, a VSCode interface, and browser tools that let the agent inspect front-end changes and JavaScript state while building real-time collaborative applications.

### Source excerpt

I'm Chris McCord, the creator of Elixir's Phoenix framework. For the past several months, I've been working on a skunkworks project at Fly.io, and it's time to show it off. I wanted LLM agents to work just as well with Elixir as they do with Python and JavaScript. Last December, in order to figure out what that was going to take, I started a little weekend project to find out how difficult it would be to build a coding agent in Elixir. A few weeks later, I had it spitting out working Phoenix applications and driving a full in-browser IDE. I knew this wasn't going to stay a weekend project. If you follow me on Twitter, you've probably seen me teasing this work as it picked up steam. We're at a point where we're pretty serious about this thing, and so it's time to make a formal introduction. World, meet Phoenix.new, a batteries-included fully-online coding agent tailored to Elixir and Phoenix. I think it's going to be the fastest way to build collaborative, real-time applications. Let's see it in action: What's Interesting About Phoenix.new First, even though it runs entirely in your browser, Phoenix.new gives both you and your agent a root shell, in an ephemeral virtual machine (a Fly Machine) that gives our agent loop free rein to install things and run programs -- without any risk of messing up your local machine. You don't think about any of this; you just open up the VSCode interface, push the shell button, and there you are, on the isolated machine you share with the Phoenix.new agent. Second, it's an agent system I built specifically for Phoenix. Phoenix is about real-time collaborative applications, and Phoenix.new knows what that means. To that end, Phoenix.new includes, in both its UI and its agent tools, a full browser. The Phoenix.new agent uses that browser "headlessly" to check its own front-end changes and interact with the app. Because it's a full browser, instead of trying to iterate on screenshots, the agent sees real page content and JavaScript state

## What are MCP Servers?

DevFeed: [What are MCP Servers?](<https://devfeed.tech/articles/what-are-mcp-servers-1711.md>)

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

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

Content type: article

Language: en

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

Topics: [Model Context Protocol](<https://devfeed.tech/topics/model-context-protocol.md>), [Model Context Protocol (MCP)](<https://devfeed.tech/topics/model-context-protocol-mcp.md>), [API](<https://devfeed.tech/topics/api.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [browser](<https://devfeed.tech/topics/browser.md>), [cursor](<https://devfeed.tech/topics/cursor.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.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>), [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>), [http](<https://devfeed.tech/tags/http.md>), [i](<https://devfeed.tech/tags/i.md>), [llm](<https://devfeed.tech/tags/llm.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [model-context-protocol](<https://devfeed.tech/tags/model-context-protocol.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [sse](<https://devfeed.tech/tags/sse.md>), [vscode](<https://devfeed.tech/tags/vscode.md>)

### AI overview

This article explains Model Context Protocol (MCP) through analogies to USB-C, Alexa Skills, and API 2.0. It describes how MCP connects AI models to data sources and tools, supports multiplexing and server push, and provides introspection about available tools and their arguments.

### Source excerpt

With Fly.io, you can get your app running globally in a matter of minutes, and with MCP servers you can integrate with Claude, VSCode, Cursor and many more AI clients. Try it out for yourself! The introduction to Model Context Protocol starts out with: MCP is an open protocol that standardizes how applications provide context to LLMs. Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect your devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools. That paragraph, to me, is both comforting ("USB for LLM"? Cool! Got it!), and simultaneously vacuous (Um, but what do I actually do with this?). I've been digging deeper and have come up with a few more analogies and observations that make sense to me. Perhaps one or more of these will help you. MCPs are Alexa Skills You buy an Echo Dot and a Hue light. You plug them both in and connect them to your Wi-Fi. There is one more step you need to do: you need to install and enable the Philips Hue skill to connect the two. Now you might be using Siri or Google Assistant. Or you may want to connect a Ring Doorbell camera or Google Nest Thermostat. But the principle is the same, though the analogy is slightly stronger with a skill (which is a noun) as opposed to the action of pairing your Hue Bridge with Apple HomeKit (a verb). MCPs are API 2.0 HTTP 1.1 is simple. You send a request, you get a response. While there are cookies and sessions, it is pretty much stateless and therefore inefficient, as each request needs to establish a new connection. WebSockets and Server-Sent Events (SSE) mitigate this a bit. HTTP 2.0 introduces features like multiplexing and server push. When you visit a web page for the first time, your browser can now request all of the associated JavaScript, CSS, and images at once, and the server can respond in any order. APIs today are typically request/response. MCPs support multi

## My AI Skeptic Friends Are All Nuts

DevFeed: [My AI Skeptic Friends Are All Nuts](<https://devfeed.tech/articles/my-ai-skeptic-friends-are-all-nuts-1724.md>)

Original publisher: [Read original article](<https://fly.io/blog/youre-all-nuts/>)

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

Content type: opinion

Language: en

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

Topics: [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [AI Bots](<https://devfeed.tech/topics/ai-bots.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.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>), [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>), [git](<https://devfeed.tech/tags/git.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>), [llms](<https://devfeed.tech/tags/llms.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

An opinionated argument that modern LLM-assisted software development relies on agents that inspect codebases, modify files, run tools, compile code, and iterate on tests. It contends that skepticism based on older LLM workflows does not reflect current coding-agent practice.

### Source excerpt

A heartfelt provocation about AI-assisted programming. Tech execs are mandating LLM adoption. That's bad strategy. But I get where they're coming from. Some of the smartest people I know share a bone-deep belief that AI is a fad -- the next iteration of NFT mania. I've been reluctant to push back on them, because, well, they're smarter than me. But their arguments are unserious, and worth confronting. Extraordinarily talented people are doing work that LLMs already do better, out of spite. All progress on LLMs could halt today, and LLMs would remain the 2nd most important thing to happen over the course of my career. Important caveat: I'm discussing only the implications of LLMs for software development. For art, music, and writing? I got nothing. I'm inclined to believe the skeptics in those fields. I just don't believe them about mine. Bona fides: I've been shipping software since the mid-1990s. I started out in boxed, shrink-wrap C code. Survived an ill-advised Alexandrescu C++ phase. Lots of Ruby and Python tooling. Some kernel work. A whole lot of server-side C, Go, and Rust. However you define "serious developer", I qualify. Even if only on one of your lower tiers. level setting † (or, God forbid, 2 years ago with Copilot) First, we need to get on the same page. If you were trying and failing to use an LLM for code 6 months ago †, you're not doing what most serious LLM-assisted coders are doing. People coding with LLMs today use agents. Agents get to poke around your codebase on their own. They author files directly. They run tools. They compile code, run tests, and iterate on the results. They also: pull in arbitrary code from the tree, or from other trees online, into their context windows, run standard Unix tools to navigate the tree and extract information, interact with Git, run existing tooling, like linters, formatters, and model checkers, and make essentially arbitrary tool calls (that you set up) through MCP. The code in an agent that actually "does st

## Using Kamal 2.0 in Production

DevFeed: [Using Kamal 2.0 in Production](<https://devfeed.tech/articles/using-kamal-2-0-in-production-1700.md>)

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

Published: 2025-05-29T00:00:00Z

Content type: opinion

Language: en

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

Topics: [Deployment](<https://devfeed.tech/topics/deployment.md>), [Docker](<https://devfeed.tech/topics/docker.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Database](<https://devfeed.tech/topics/database.md>), [Rails](<https://devfeed.tech/topics/rails.md>)

Tags: [cdn](<https://devfeed.tech/tags/cdn.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [database](<https://devfeed.tech/tags/database.md>), [deploy-app-servers](<https://devfeed.tech/tags/deploy-app-servers.md>), [deployment](<https://devfeed.tech/tags/deployment.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>), [github](<https://devfeed.tech/tags/github.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.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>), [load-balancer](<https://devfeed.tech/tags/load-balancer.md>), [markdown](<https://devfeed.tech/tags/markdown.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

An opinionated guide to using Kamal 2.0 in production, covering the surrounding Docker ecosystem, container repositories, secrets, load balancing, managed databases, backups, searchable logs, monitoring, security, SSH keys, and hosting choices. The author explains that GitHub Copilot helped convert XML notes to Markdown and proofread the resulting online publication.

### Source excerpt

Agile Web Development with Rails 8 is off to production, where they do things like editing, indexing, pagination, and printing. In researching the chapter on Deployment and Production, I became very dissatisfied with the content available on Kamal. I ended up writing my own, and it went well beyond the scope of the book. I then extracted what I needed from the result and put it in the book. Now that I have some spare time, I took a look at the greater work. It was more than a chapter and less than a book, so I decided to publish it online. This took me only a matter of hours. I had my notes in the XML grammar that Pragmatic Programming uses for books. I asked GitHub Copilot to convert them to Markdown. It did the job without my having to explain the grammar. It made intelligent guesses as to how to handle footnotes and got a number of these wrong, but that was easy to fix. On a lark, I asked it to proofread the content, and it did that too. Don't get me wrong, Kamal is great. There are plenty of videos on how to get toy projects online, and the documentation will tell you what each field in the configuration file does. But none pull together everything you need to deploy a real project. For example, there are seven things you need to get started. Some are optional, some you may already have, and all can be gathered quickly if you have a list. Kamal is just one piece of the puzzle. To deploy your software using Kamal, you need to be aware of the vast Docker ecosystem. You will want to set up a builder, sign up for a container repository, and lock down your secrets. And as you grow, you will want a load balancer and a managed database. And production is much more than copying files and starting a process. It is ensuring that your database is backed up, that your logs are searchable, and that your application is being monitored. It is also about ensuring that your application is secure. My list is opinionated. Each choice has a lot of options. For SSH keys, there are a

## A Bug in Fly.io's Rust Anycast Router

DevFeed: [A Bug in Fly.io's Rust Anycast Router](<https://devfeed.tech/articles/parking-lot-ffffffffffffffff-1714.md>)

Original publisher: [Read original article](<https://fly.io/blog/parking-lot-ffffffffffffffff/>)

Published: 2025-05-28T00:00:00Z

Content type: article

Language: en

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

Topics: [fly.io](<https://devfeed.tech/topics/fly-io.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [networking](<https://devfeed.tech/topics/networking.md>), [Tokio](<https://devfeed.tech/topics/tokio.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.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>), [network](<https://devfeed.tech/tags/network.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [proxy](<https://devfeed.tech/tags/proxy.md>), [rust](<https://devfeed.tech/tags/rust.md>), [servers](<https://devfeed.tech/tags/servers.md>), [tokio](<https://devfeed.tech/tags/tokio.md>)

### AI overview

Fly.io describes a bug in fly-proxy, its Rust Anycast router. The post explains the challenge of distributing rapidly changing routing state for apps and connections across its infrastructure.

### Source excerpt

We're Fly.io, a public cloud that runs apps in a bunch of locations all over the world. This is a post about a gnarly bug in our Anycast router, the largest Rust project in our codebase. You won't need much of any Rust to follow it. The basic idea is simple: customers give us Docker containers, and tell us which one of 30+ regions around the world they want them to run in. We convert the containers into lightweight virtual machines, and then link them to an Anycast network. If you boot up an app here in Sydney and Frankfurt, and a request for it lands in Narita, it'll get routed to Sydney. The component doing that work is called fly-proxy. It's a Rust program, and it has been ill behaved of late. Dramatis Personae fly-proxy, our intrepid Anycast router. corrosion, our intrepid Anycast routing protocol. Rust, a programming language you probably don't use. read-write locks, a synchronization primitive that allows for many readers or one single writer. parking_lot, a well-regarded optimized implementation of locks in Rust. Gaze not into the abyss, lest you become recognized as an abyss domain expert, and they expect you keep gazing into the damn thing Mathewson 6:31 Anycast Routing You already know how to build a proxy. Connection comes in, connection goes out, copy back and forth. So for the amount of time we spend writing about fly-proxy, you might wonder what the big deal is. To be fair, in the nuts and bolts of actually proxying requests, fly-proxy does some interesting stuff. For one thing, it's written in Rust, which is apparently a big deal all on its own. It's a large, asynchronous codebase that handles multiple protocols, TLS termination, and certificate issuance. It exercises a lot of Tokio features. But none of this is the hard part of fly-proxy. We operate thousands of servers around the world. A customer Fly Machine might get scheduled onto any of them; in some places, the expectation we set with customers is that their Machines will potentially start in l

## Litestream: Revamped

DevFeed: [Litestream: Revamped](<https://devfeed.tech/articles/litestream-revamped-1703.md>)

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

Published: 2025-05-20T00:00:00Z

Content type: article

Language: en

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

Topics: [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [Server](<https://devfeed.tech/topics/server.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>)

Tags: [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>), [deployment](<https://devfeed.tech/tags/deployment.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>), [mysql](<https://devfeed.tech/tags/mysql.md>), [networking](<https://devfeed.tech/tags/networking.md>), [object-storage](<https://devfeed.tech/tags/object-storage.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>)

### AI overview

This article describes a major redesign of Litestream, an open-source tool for making SQLite applications recoverable through continuous replication to S3-compatible object storage. It explains Litestream's original architecture and introduces improvements informed by LiteFS, including faster point-in-time restores.

### Source excerpt

Litestream is an open-source tool that makes it possible to run many kinds of full-stack applications on top of SQLite by making them reliably recoverable from object storage. This is a post about the biggest change we've made to it since I launched it. Nearly a decade ago, I got a bug up my ass. I wanted to build full-stack applications quickly. But the conventional n-tier database design required me to do sysadmin work for each app I shipped. Even the simplest applications depended on heavy-weight database servers like Postgres or MySQL. I wanted to launch apps on SQLite, because SQLite is easy. But SQLite is embedded, not a server, which at the time implied that the data for my application lived (and died) with just one server. So in 2020, I wrote Litestream to fix that. Litestream is a tool that runs alongside a SQLite application. Without changing that running application, it takes over the WAL checkpointing process to continuously stream database updates to an S3-compatible object store. If something happens to the server the app is running on, the whole database can efficiently be restored to a different server. You might lose servers, but you won't lose your data. Litestream worked well. So we got ambitious. A few years later, we built LiteFS. LiteFS takes the ideas in Litestream and refines them, so that we can do read replicas and primary failovers with SQLite. LiteFS gives SQLite the modern deployment story of an n-tier database like Postgres, while keeping the database embedded. We like both LiteFS and Litestream. But Litestream is the more popular project. It's easier to deploy and easier to reason about. There are some good ideas in LiteFS. We'd like Litestream users to benefit from them. So we've taken our LiteFS learnings and applied them to some new features in Litestream. Point-in-time restores, but fast Here's how Litestream was originally designed: you run litestream against a SQLite database, and it opens up a long-lived read transaction. This t

## Launching MCP Servers on Fly.io

DevFeed: [Launching MCP Servers on Fly.io](<https://devfeed.tech/articles/launching-mcp-servers-on-fly-io-1709.md>)

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

Published: 2025-05-19T00:00:00Z

Content type: opinion

Language: en

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

Topics: [Model Context Protocol](<https://devfeed.tech/topics/model-context-protocol.md>), [MCP Server](<https://devfeed.tech/topics/mcp-server.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>), [OAuth](<https://devfeed.tech/topics/oauth.md>), [Security](<https://devfeed.tech/topics/security.md>), [Slack](<https://devfeed.tech/topics/slack.md>)

Tags: [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>), [json](<https://devfeed.tech/tags/json.md>), [linux](<https://devfeed.tech/tags/linux.md>), [macos](<https://devfeed.tech/tags/macos.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [model-context-protocol](<https://devfeed.tech/tags/model-context-protocol.md>), [networking](<https://devfeed.tech/tags/networking.md>), [oauth](<https://devfeed.tech/tags/oauth.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [servers](<https://devfeed.tech/tags/servers.md>), [slack](<https://devfeed.tech/tags/slack.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

This opinionated blog post introduces Fly.io's approach to launching MCP Servers. It explains the trade-offs between local process-based servers and remote HTTP servers, including configuration complexity and OAuth 2.1 security requirements, then demonstrates a Slack MCP Server for interacting with Slack workspaces.

### Source excerpt

This is a blog post. Part showing off. Part opinion. Plan accordingly. The Model Context Protocol is days away from turning six months old. You read that right, six months old. MCP Servers have both taken the world by storm, and still trying to figure out what they want to be when they grow up. There is no doubt that MCP servers are useful. But their appeal goes beyond that. They are also simple and universal. What's not to like? Well, for starters, there's basically two types of MCP servers. One small and nimble that runs as a process on your machine. And one that is a HTTP server that runs presumably elsewhere and is standardizing on OAuth 2.1. And there is a third type, but it is deprecated. Next there is the configuration. Asking users to manually edit JSON seems so early 21th century. With Claude, this goes into ~/Library/Application Support/Claude/claude_desktop_config.json, and is found under a MCPServer key. With Zed, this file is in ~/.config/zed/settings.json and is found under a context_servers key. And some tools put these files in a different place depending on whether you are running on MacOS, Linux, or Windows. Finally, there is security. An MCP server running on your machine literally has access to everything you do. Running remote solves this problem, but did I mention OAuth 2.1? Not exactly something one sets up for casual use. None of these issues are fatal - something that is obvious by the fact that MCP servers are quite popular. But can we do better? I think so. Demo time. Let's try out the Slack MCP Server: MCP Server for the Slack API, enabling Claude to interact with Slack workspaces. That certainly sounds like a good test case. There is a small amount of setup you need to do, and when you are done you end up with a Bot User OAuth Token staring with xoxb- and a Team ID starting with a T. You would run it using the following: Wrap text Copy to clipboard npx -y @modelcontextprotocol/server-slack But instead, you convert that command to JSON an

## Provisioning Machines using MCPs

DevFeed: [Provisioning Machines using MCPs](<https://devfeed.tech/articles/provisioning-machines-using-mcps-1710.md>)

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

Published: 2025-05-07T00:00:00Z

Content type: opinion

Language: en

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

Topics: [Provisioning](<https://devfeed.tech/topics/provisioning.md>), [Model Context Protocol](<https://devfeed.tech/topics/model-context-protocol.md>), [fly.io](<https://devfeed.tech/topics/fly-io.md>), [fly](<https://devfeed.tech/topics/fly.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [cursor](<https://devfeed.tech/topics/cursor.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [claude](<https://devfeed.tech/tags/claude.md>), [close-to-users](<https://devfeed.tech/tags/close-to-users.md>), [copilot](<https://devfeed.tech/tags/copilot.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>), [fly](<https://devfeed.tech/tags/fly.md>), [fly-io](<https://devfeed.tech/tags/fly-io.md>), [github](<https://devfeed.tech/tags/github.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>), [mcps](<https://devfeed.tech/tags/mcps.md>), [networking](<https://devfeed.tech/tags/networking.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [provisioning](<https://devfeed.tech/tags/provisioning.md>), [servers](<https://devfeed.tech/tags/servers.md>), [terraform](<https://devfeed.tech/tags/terraform.md>)

### AI overview

The author describes using MCP with Claude to create and manage Fly.io volumes, including deleting an unattached volume. The article argues that connecting LLMs to infrastructure tools can make application resource management more intuitive than using APIs, CLIs, or dashboards.

### Source excerpt

Today's state of the art is K8S, Terraform, web based UIs, and CLIs. Those days are numbered. On Monday, I created my first fly volume using an MCP. For those who don't know what MCPs are, they are how you attach tools to LLMs like Claude or Cursor. I added support for fly volume create to fly mcp server, and it worked the first time. A few hours later, and with the assistance of GitHub Copilot, i added support for all fly volumes commands. This movie summary is from When Worlds Collide, by Nalaka Gunawardene I'm reminded of the memorable scene in the film Star Trek IV: The Voyage Home (1986). Chief Engineer Scotty, having time-travelled 200 years back to late 20th century San Francisco with his crew mates, encounters an early Personal Computer (PC). Sitting in front of it, he addresses the machine affably as "Computer!" Nothing happens. Scotty repeats himself; still no response. He doesn't realise that voice recognition capability hadn't arrived yet. Exasperated, he picks up the mouse and speaks into it: "Hello, computer?" The computer's owner offers helpful advice: "Just use the keyboard." Scotty looks astonished. "A keyboard?" he asks, and adds in a sarcastic tone: "How quaint!" A while later, I asked for a list of volumes for an existing app, and Claude noted that I had a few volumes that weren't attached to any machines. So I asked it to delete the oldest unattached volume, and it did so. Then it occurred to me to do it again; this time I captured the screen: A few notes: I could have written a program using the machines API, but that would have required some effort. I could have used flyctl directly, but to be honest, I would have had to use the documentation and a bit of copy/pasting of arguments. I could have navigated to a list of volumes for this application in the Fly.io dashboard, but there currently isn't any way to sort the list or delete a volume. Had those been in place, that would have been a reasonable alternative if that was something I was active

## 30 Minutes With MCP and flyctl

DevFeed: [30 Minutes With MCP and flyctl](<https://devfeed.tech/articles/30-minutes-with-mcp-and-flyctl-1685.md>)

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

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

Content type: article

Language: en

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

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

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [cdn](<https://devfeed.tech/tags/cdn.md>), [claude](<https://devfeed.tech/tags/claude.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>), [go](<https://devfeed.tech/tags/go.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>), [json](<https://devfeed.tech/tags/json.md>), [llm](<https://devfeed.tech/tags/llm.md>), [logs](<https://devfeed.tech/tags/logs.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>), [python](<https://devfeed.tech/tags/python.md>), [servers](<https://devfeed.tech/tags/servers.md>)

### AI overview

A developer describes building a minimal MCP server for flyctl in 30 minutes. The server exposes flyctl status and log commands so an LLM can inspect an application and investigate unhealthy machines.

### Source excerpt

I wrote this post on our internal message board, and then someone asked, "why is this an internal post and not on our blog", so now it is. well, Cursor built I built the most basic MCP server for flyctl I could think of. It took 30 minutes. MCP, for those unaware, is the emerging standard protocol for connecting an LLM (or an app that drives an LLM in the cloud, like Claude Desktop) to, well, anything. The "client" in MCP is the LLM; the "server" is the MCP server and the "tools" it exports. It mostly just defines an exchange of JSON blobs; one of those JSON blobs enables the LLM to discover all the tools exported by the server. A classic example of an MCP server is (yes, really) a Python shell. MCP publishes to (say) Claude that it can run arbitrary Python code with a tool call; not only that, says the tool description, but you can use those Python tool calls to, say, scrape the web. When the LLM wants to scrape the web with Python, it uses MCP send a JSON blob describing the Python tool call; the MCP server (yes, really) runs the Python and returns the result. Because I have not yet completely lost my mind, I chose to expose just two flyctl commands: fly logs and fly status. Because I'm lazy, I used MCP's stdio mode; the MCP server just captures the output of flyctl. Because someone already wrote a really good Go MCP library , this whole thing is like 90 lines of code. We may have gotten a little lucky, because we made a decision back in 2020 to give most of our flyctl commands a json mode to make them easier to drive from automation. I use that in my MCP server. I don't know how much of a difference it made. It's, uh, annoyingly useful. I loaded it up and pointed it at unpkg. I got this, from Claude: This appears to be a globally distributed CDN service running the unpkg JavaScript package registry, with machines strategically placed around the world to provide low-latency access. There are some stability issues with a couple of the machines, and several have exp

[Next page](<https://devfeed.tech/tags/deploy-app-servers.md?cursor=WyIyMDI1LTA0LTEwVDAwOjAwOjAwKzAwOjAwIiwgIjVkZDNmZjY2LWY2YzktNDAzYi05ZmYwLTc0Y2U1NmQwOTk4NSJd>)