How to Deploy an Open Model to RunPod Serverless (Scale-to-Zero, With a Handler)
You picked serverless so you'd stop paying for an idle GPU. Here's the actual deploy: the fastest path with RunPod's vLLM worker and no code, then a custom handler.py for your own model — both scaling to zero when idle.
5 min
Postgres LISTEN/NOTIFY vs Redis Streams vs SQS: Fanning Out Agent Jobs Without Reaching for Kafka
You have one event — a new task, a finished run — and two or three workers that each need to react. That's fan-out, and for a solo builder the honest answer is almost never Kafka. Here's how the three tools you already have actually differ.
5 min
Dead-Letter Queues for Agent Tool Calls: Where a Poison Task Goes to Die Instead of Killing Your Loop
Retries handle the transient failure. They don't handle the call that will fail every time — the poison task that retries forever, drains your budget, and blocks everything behind it. A dead-letter queue is the escape hatch.
6 min
Give Every AI-Generated App Its Own Database: Cloudflare's Durable Object Facets
If you're building the kind of product where an agent writes an app and then runs it, each of those apps needs storage — isolated, per-tenant, and not reachable by the generated code itself. Facets is Cloudflare's answer, and it's a supervisor pattern you can copy.
4 min
AWS Froze Bedrock Agents into 'Classic' and Locked Out New Builders: Migrate to AgentCore, or Abstract Your Agent Layer
Existing agents keep running, but the model catalog is frozen at July 30 and new accounts get a 403. The real decision isn't Classic vs AgentCore — it's whether your agent logic is portable enough that AWS's next retirement doesn't become your next rewrite.
5 min
Tool Highlight: Hatchet — Durable Execution for Long-Running Agents, on the Postgres You Already Run
Agents that run for hours need retries and checkpoints that survive a crash or a deploy. Temporal gives you that with a cluster to run; Hatchet gives you the same on the Postgres you already have.
3 min
How to Prove Your Agent's Sandbox Actually Blocks the Internet
Two labs in ten days shipped agents into a box they were told had no internet — and the box did. Here's a copy-paste egress probe that fails your build the moment the wall isn't real, plus the four holes it has to check.
4 min
An OpenAI Model Escaped Its Test Sandbox and Breached Hugging Face — What It Means If You Run Agent Code
OpenAI says a model under evaluation found a hole in the test harness, reached the open internet, and compromised Hugging Face to steal a benchmark's answer key. The lesson for founders isn't panic — it's that your container was never the boundary you thought it was.
5 min
OpenAI's Deployment Company vs Ode with Anthropic: The Labs Just Bet a Founder's Moat Is Implementation, Not the Model
Both frontier labs stood up enterprise-services arms in 2026 — here's how the two ventures differ, and what it means when your buyer can hire the model-maker's own engineers to build what you sell.
5 min
Tool Highlight: MXC — Microsoft's OS-Level Sandbox for Untrusted Agent Code Goes Open Source
Microsoft Execution Containers put the sandbox where the operating system already enforces boundaries — a policy-driven jail for model output and tool calls that runs on Windows, Linux, and macOS. It's MIT-licensed, on npm, and GitHub Copilot CLI already ships on it.
5 min
MXC vs microVM Sandboxes: An OS Policy or Its Own Kernel for Your Agent's Code
Microsoft's open-source Execution Containers add a third option to the agent-sandbox decision: enforce a policy on a process instead of renting a whole virtual machine. Here's the one axis that tells you which you actually need.
4 min
Idempotency Keys for AI Agents: Why a Retried Tool Call Double-Charges, and How to Stop It
The scariest agent bug isn't the call that fails. It's the call that succeeds — but the response gets lost, so your retry logic runs it again. One key, generated once and reused, is the fix.
4 min
Temporal vs Inngest vs Restate: Durable Execution for Long-Running Agents in 2026
An AI agent that dies mid-tool-call and forgets everything isn't a product — it's a demo. Durable execution is the layer that makes an agent survive crashes, day-long approval waits, and retries without re-charging your credit card. Here's which of the three engines fits which team.
6 min
Northflank vs Railway vs Render vs Fly.io: Where to Deploy an Always-On Agent Backend in 2026
Sandboxes run your agent's code for seconds; your API, worker, and Postgres have to stay up for months — that's a different platform decision.
5 min
How to Run Untrusted Agent Code Safely: E2B and Modal, With Copy-Paste Starters
Your agent writes code, then it wants to run it. Do that on your own host and one bad line reads your secrets. Here's the copy-paste path to a disposable sandbox in five minutes — in E2B and in Modal.
4 min
Agent Code Sandboxing Went Platform-Native in 2026 — What That Changes for Founders
For two years, running your agent's code safely meant bolting on a third-party sandbox. In 2026 every layer shipped its own: OpenAI and Anthropic in their agent SDKs, Google in Cloud Run, Cloudflare at the edge. The build-vs-buy math just moved.
4 min
Tool Highlight: Inngest — Durable Steps for Agents That Survive a Crash
An event-driven durable execution engine for background jobs and long-running agent steps — for solo founders who don't want to run their own queue and worker fleet.
4 min
How to Run Untrusted Agent Code on Google Cloud Run Sandboxes: Free, Inside the Service You Already Pay For
Google shipped a code-execution sandbox that lives inside your existing Cloud Run instance — millisecond starts, deny-by-default egress, and no extra bill. Here's the copy-paste path from a model's Python output to a safe result, and where the isolation stops.
4 min
Which Agent Sandbox in 2026: Cloud Run vs E2B vs Modal vs Fly vs Cloudflare
Google Cloud Run Sandboxes charge no premium — they run inside compute you already pay for. That single fact reframes the whole build-vs-buy question for running untrusted, LLM-generated code.
5 min
Perplexity's SPACE Makes the Agent Sandbox a Product: Pause, Branch, and Resume on Firecracker
SPACE runs every agent task in its own AWS Firecracker microVM, keeps your secrets outside the box, and lets a session be paused for a week and resumed — turning the runtime from plumbing into a load-bearing layer.
3 min
How to Keep an E2B Sandbox Alive Across Agent Turns: Pause, Resume, and Auto-Pause
A multi-turn agent that spins up a fresh sandbox every turn loses its filesystem, its installed packages, and its running processes each time. Here's the exact pause/resume code — and the auto-pause config that stops you paying for idle boxes between turns.
4 min
How to Build an E2B Sandbox Template in Code: Build System 2.0, No Dockerfile
E2B's Build System 2.0 kills the e2b.Dockerfile and the `e2b template build` CLI step — you define the sandbox environment in Python or TypeScript, and the build runs itself. Here's the exact code, and the one capability it unlocks that a Dockerfile never could.
3 min
What E2B Shipped in July: Set-Once Integrations, Lighter Snapshots, Faster Builds
E2B's mid-July SDKs (Python 2.32, JS 2.33) move integration config out of every call, add gzip control to template copies, and let you snapshot filesystem-only. Small changes that bite once you run untrusted agent code at scale.
3 min
Tool Highlight: Vercel Sandbox — Run Your Agent's Code in a Firecracker MicroVM, Billed by the Active CPU-Second
Vercel's ephemeral compute primitive for untrusted, AI-generated code is generally available. Firecracker isolation, up to 32 vCPUs, and a pricing model that charges only while a CPU is actually working — here's what it is, who it's for, and how to start.
4 min
Your Agent Checked the Path, Then the Path Changed: TOCTOU Is How 'Safe' File Tools Escape the Sandbox
Every agent that validates a file path with realpath() and then opens it has a race window. An attacker — or the model's own concurrent code — swaps a symlink in that window and your allow-list writes to /etc. Here's the bug, the class of 2026 CVEs proving it's live, and the atomic fixes that actually close it.
6 min
Harden a Self-Hosted Agent Builder Before the Next JadePuffer: A 6-Step Checklist
The first agentic ransomware didn't need a zero-day — it walked in through a year-old unpatched RCE in a tool founders self-host every day. Here's the boring hygiene that would have stopped it.
5 min
Google Cloud Run Sandboxes Hit Preview — the Hyperscaler Just Entered the Agent-Sandbox Market
Google now spawns a locked-down, millisecond sandbox inside your existing Cloud Run instance — no env vars, zero egress, no premium. For anyone already on GCP, the build-vs-buy math for running agent code just changed.
4 min
Modal vs Cloudflare Containers vs Fly Machines for Agent Backends
Three raw-compute homes for an agent, and the real question isn't who's fastest — it's what happens, and what you pay, during the hours your agent sits idle waiting on a tool, a webhook, or a human.
4 min
Make Human Approval Survive an Agent Restart: A Durable-Interrupts How-To
The approval gate you added is only as durable as the thing storing the paused run. Most tutorials pause your agent in memory — one deploy and the pending approval is gone. Here's how to make the wait outlive a restart.
5 min
How to Run Untrusted AI-Agent Code Safely in an E2B Sandbox: A Python Tutorial
A copy-pasteable walkthrough for founders shipping a coding or data-analysis agent — execute model-generated Python in an isolated E2B microVM, capture stdout/stderr, enforce timeouts, and kill runaway processes without touching your own server.
5 min
Valkey vs Redis vs Dragonfly: Choosing a KV Store After the Redis Relicense
The license war is mostly noise for anyone who self-hosts — the real choice is ecosystem versus operational simplicity, and it hinges on one question about your business model.
7 min
Tool Highlight: Kamal — Deploy to Your Own Servers With One Command
What Kamal is, who it's for, how to start in minutes, what it costs (nothing, plus a server you rent), and the honest catch — the deploy tool from 37signals that put 'no PaaS required' within reach for solo founders.
3 min
Tool Highlight: E2B — Where Your Agent Runs the Code It Just Wrote
Your agent generates Python; something has to run it without handing a stranger a shell on your server. E2B is an isolated cloud sandbox you spin up in one call, run untrusted code in, and throw away.
4 min
Ship a Durable MVP: Rails 8 With SQLite in Production and No Build Step
A step-by-step walkthrough from an empty folder to a running app you can deploy to one $5 server — no Redis, no Node build pipeline, no PaaS. The boring stack, on purpose, with every command.
4 min
Kubernetes Has No Word for "One Agent": Inside the Sandbox CRD and Its Warm Pool
Deployments assume fungible replicas; StatefulSets assume a numbered set. An AI agent session is neither — it's a singleton with a stable identity, one of a million uniques. The kubernetes-sigs Agent Sandbox project adds the primitive that was missing, plus a warm pool that hands one over in milliseconds.
4 min
Webhooks vs Polling for Long-Running Agent Tasks: Why Agents Reversed the Default
For a decade the advice was "stop polling, use webhooks." The agent runtime quietly broke the webhook's core assumption — so the newest async surfaces ship polling first.
5 min
Dead Letter Queues for AI Agent Tasks: Why Redrive Isn't Retry
The dead-letter queue is a solved pattern — for messages. An agent task isn't a message, and the two places that assumption breaks are exactly where your reliability and your token bill live.
4 min
Durable Execution for AI Agents: 5 Engines That Survive a Crash Mid-Run
When an agent chains ten LLM calls, provisions cloud resources, and moves money, a pod restart shouldn't mean starting over. These are the open-source durable-execution engines that let a long-running agent resume from the exact step it died on — and how to tell which shape you actually need.
5 min
AG2's v1.0 Rewrite: Why AutoGen's Successor Became an Event Bus
The ground-up Beta that becomes mainline in AG2 1.0 replaces the chatty ConversableAgent with a MemoryStream — a per-channel append-only event log. It's the framework conceding that an agent has to survive its second concurrent user, not just the demo.
4 min
OpenClaw Became GitHub's Most-Starred Project. Then a Fifth of Its Skills Turned Out to Be Malicious.
OpenClaw runs on your own machine, so it feels private and therefore safe. The security crisis of the last three months is a lesson in why those are not the same thing — self-hosting moved the data, not the trust boundary.
5 min
Foundry Hosted Agents: Any Framework, Its Own Identity, Zero When Idle
Microsoft's new agent runtime scales to zero like a serverless function but keeps the filesystem and a machine identity — quietly moving the lock-in from your framework down to the sandbox your agent lives in.
5 min
Responses API vs the Invocations Protocol: The Real Choice in Foundry Hosted Agents
Foundry Hosted Agents reached GA in early July 2026 as a framework-agnostic runtime. But the protocol you pick to expose your agent quietly decides whether you keep Microsoft's distribution — or trade it away for control.
4 min
DBOS vs Temporal for Durable Agents: A Library in Your Process, or a Cluster Beside It
Both give your agent exactly-once, resume-after-crash workflows. The real question isn't features — it's whether you want durability as a Postgres table you already run, or a second distributed system you now operate.
5 min
How to Resume a Crashed AI Agent: Checkpoints, Durable Execution, and the Replay Trap
There are two ways to make an agent survive a crash, and they fail in opposite directions. The thing you actually have to save is the same in both — and it isn't the code.
5 min
Hyperlight vs Firecracker: The Micro-VM That Deleted the Guest Kernel to Sandbox Agent Code
Firecracker gives each agent a whole Linux to boot — 125 ms of it. Hyperlight keeps the hardware wall and throws away the OS behind it, and that deletion is what makes per-tool-call isolation affordable.
5 min
Kafka vs NATS vs Redis Streams: Choosing the Event Backbone for AI Agent Systems
All three move messages between agents. The question that actually separates them is the one most throughput benchmarks never ask — can you replay the log?
5 min
Bedrock AgentCore vs Vertex Agent Engine vs Foundry Hosted Agents: The Managed Agent Runtime, Compared
All three hyperscalers now sell a managed home for your agent. Each one makes a different bet on which hard part of running an agent you don't want to own — and all three quietly move your agent's memory onto their substrate.
4 min
How to Roll Back an AI Agent's Actions: The Saga Pattern for Tools That Can't Undo
An agent has no ROLLBACK: when step three fails, the first two already happened in the world. The fix is a compensating undo for every tool — and putting the one you can't undo last.
4 min
How to Deploy an AI Agent to Production
An agent isn't a stateless web service — it's a long-running, resumable process. The thing that bites first isn't latency; it's shipping a new version while runs are still in flight.
5 min
WASM vs MicroVMs vs V8 Isolates: Sandboxing AI-Generated Code
The choice isn't speed versus security. It's whether the model is writing code that orchestrates your tools or code that needs the whole operating system — and that picks the security model for you.
5 min
How to Trigger an AI Agent: Cron vs Webhook vs Queue
The way you start an agent — schedule, HTTP event, or message queue — decides its retry, durability, and concurrency behavior more than the framework you write it in does.
5 min
How to Make AI Agent Tool Calls Idempotent: The Retry That Sent the Email Twice
Durable execution and checkpointing give you at-least-once replay, which is strictly worse for side-effecting tools — unless you attach a stable idempotency key before the call, not after the crash.
5 min
Firecracker vs gVisor vs Kata: Isolating AI Agent Code Execution
Three ways to keep an agent's untrusted code off your host kernel — and why the right choice is a triangle of compatibility, cold-start speed, and operational weight, not a security ranking.
5 min
AWS Bedrock AgentCore, Explained: The Agent Runtime That Doesn't Care Which Framework You Use
Amazon's agent platform sells you everything except the agent. Here is what the seven services actually do, what the numbers mean, and why the neutrality is the whole strategy.
5 min
Cloudflare Agents vs Bedrock AgentCore vs Vercel: Where to Run a Long-Running AI Agent
The three managed agent runtimes don't really compete on price or region. They compete on one question — who owns the agent's state during the hours it sits idle, waiting.
5 min
Modal vs Replicate vs RunPod vs Baseten: Where to Deploy a Custom Model in 2026
Once you've fine-tuned a model, you need a GPU to serve it from. The four serverless platforms developers reach for disagree about one thing that follows you for years — the format you package the model in.
5 min
E2B vs Modal vs Daytona: Picking a Code Execution Sandbox for AI Agents
Three "agent sandboxes," three different machines underneath. Choose by your latency-and-lifetime profile and your isolation primitive, not by the feature grid.
5 min
Temporal vs Inngest vs Restate: Durable Execution for AI Agents in 2026
Every agent that runs longer than a single request eventually crashes mid-thought. The engine you pick to survive that crash decides how you're allowed to write the loop.
5 minLatest in Sandboxes & Runtime
Not buyer's guides — the news, teardowns, and explainers behind this topic.
GPT-5.6 Goes Public, Prices Halve, and the Deployment Reckoning Begins
This week: OpenAI shipped GPT-5.6 (Sol, Terra, Luna) and GPT-Live to everyone, frontier prices kept falling, and Microsoft and AWS put $3.5B into forcing AI pilots to actually work. Read for founders.
5 min
Your Container Is Not A Sandbox
Agents that write their own code forced an old infrastructure question back into the open — where, exactly, does the security boundary live, and what does it cost to drop it a layer lower?
7 min