Fly.io

Sprites gain an MCP interface so agents can spin up their own disposable VMs — shipped with an open argument from its builders that command-line tools and discoverable APIs beat MCP, which pays a context tax for every tool description.

Adding volume commands to a cloud CLI's MCP server, then letting Claude find and clean up orphaned volumes on its own — a hands-on look at what conversational infrastructure provisioning does to the CLI-and-Terraform status quo.

Sprites are persistent, second-to-boot Linux VMs with durable filesystems and instant checkpoints, pitched as a replacement for the throwaway read-only sandbox that agent harnesses currently default to — keep the environment, don't rebuild it each run.

An argument against building for model portability: swapping an LLM is never just changing an endpoint, and as providers converge on similar baselines, the differentiation moves to how deeply you have tuned the product around one model's behavior.

How three Elixir pieces — Livebook notebooks, FLAME's elastic executor pools, and the Nx/Axon tensor stack — combine so you can drive remote GPU clusters from a laptop notebook without rearchitecting the app into serverless fragments.

Chris McCord launches Phoenix.new, a browser-based coding agent tailored to Elixir and Phoenix. The agent gets root in an ephemeral VM with a full shell and VSCode interface, aimed at closing the gap between Elixir and the Python/JS ecosystems agents handle best.

A veteran systems programmer takes apart the standard objections to LLM-assisted coding, insisting that agent setups which actually run and iterate on generated code are a different thing from the autocomplete critics tried two years ago.

How Sprites are actually built: full Linux VMs with root access and 100GB durable root filesystems that create in a second or two and suspend themselves when idle, assembled without the conventional container stack underneath.

An argument that agents are the rare technology you have to build to understand, followed by the smallest working loop: a context list, a model call, and tool dispatch. Useful whether you are trying to adopt agents or to criticise them accurately.

Recursive agent rules — teaching a coding agent to author and organize its own standing constraints — and why a semantics-aware pattern tool like Semgrep looks far more interesting once an LLM can generate and maintain the rules for it.

A blind Fly engineer builds image description on open-source vision models, using everyday accessibility problems — find the coffee cup, find the light switch — as the test case, and shows how to extend the project yourself.

Trust calibration — matching how much users trust an AI feature to what it can actually do — pulled from the human-automation literature and applied to AI products, with the failure modes on both sides of the line spelled out.

Argues that containers are insufficient for running agent-generated or user-submitted code because they share the host kernel. Recommends hardware-isolated sandboxes with a dedicated kernel and default-deny network egress to block exfiltration and payload downloads.

Examines how OpenClaw manages agent memory: append-only logs that fade in relevance, a deliberately promoted long-term memory file, and hybrid BM25 and vector recall with diversity re-ranking over local SQLite. Argues context engineering is mostly disciplined note-keeping.

Where an agent lives and where it runs code are separable decisions. Keeping the loop persistent while pushing migrations, installs and deletions into throwaway environments avoids the tradeoffs of stuffing the whole agent in a sandbox.

Why leaderboard benchmarks tell you little about how a model behaves over long contexts or in character, and how game environments — Kaggle Game Arena, a one-click AI Town deploy — turn subjective side-by-side comparisons into something watchable.

An attempt to make Model Context Protocol concrete beyond the official analogy, working through what an MCP server actually exposes to an LLM and why the Alexa-skill and 'API 2.0' framings explain the discovery model better.

Fly halves L40S GPU pricing to $1.25/hour and explains the demand picture behind it: the weakest card in the lineup, the A10, is the runaway favorite because it is adequate for most inference and mid-sized generative workloads.

A public cloud reports back on the GPU bet it placed two years ago: hardware-mapped Nvidia GPUs inside Firecracker-class VMs turned out to be an expensive answer to a question inference customers were not asking. An unusually honest read on where AI compute demand actually landed.

The unglamorous parts of shipping an MCP server: two live transports plus a deprecated one, client config files scattered across different paths per tool and OS, and the security gap between a local process with full machine access and an OAuth-protected remote.

A cloud provider reports that agent harnesses, not people, account for most of its recent growth, and works through the consequence: a decade of CLI and developer-experience polish matters less than APIs and environments that agents can drive.

Wrapping two CLI commands as MCP tools in roughly 90 lines and half an hour, using stdio transport and an off-the-shelf Go library — a stripped-down demonstration of what building an MCP server actually involves.